Quels sont les appels équivalents de ces fonctions JavaScript dans un ByteArray AS3?

Question

Je convertis la fonction de JavaScript en AS3 et j'essaie de mapper les appels entre Uint8Array et ByteArray et je remarque que quelques-uns des appels sont différents.

var data = new Uint8Array() // Javascript 
var bytearray = new ByteArray(); // AS3 

Liste des appels en Javascript ne trouve pas dans AS3:

readUnicodeString() 
readString() 
readLongLong() 
read() 
tell() 

Mise à jour:
On dirait que l'auteur utilise Uint8Array mais aussi de créer une classe de repli où Uint8Array n'est pas pris en charge. Je vais devoir mettre à jour cette question quand je pourrai comprendre ce qui se passe.

Mise à jour 2:
Ainsi, un Uint8Array est passé et alors que Uint8Array est passé dans une classe d'emballage:

Image = function (data) { 
    this.file = new File(data); 
    ... 
} 

var image = new Image(new Uint8Array(buffer)); 

plus tôt ...

File.prototype.readString = function(length) { 
    return String.fromCharCode.apply(null, this.read(length)).replace(/\u0000/g, ""); 
}; 

File.prototype.readUnicodeString = function(length) { 
    if (length == null) { 
     length = null; 
    } 
    length || (length = this.readInt()); 
    return iconv.decode(new Buffer(this.read(length * 2)), 'utf-16be').replace(/\u0000/g, ""); 
}; 

File.prototype.read = function(length) { 
    var i, j, ref, results; 
    results = []; 
    for (i = j = 0, ref = length; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) { 
     results.push(this.data[this.pos++]); 
    } 
    return results; 
}; 

Maintenant, la question est légèrement différent.

Mise à jour 3:

Certains plus d'informations dans post connexes. Voici ma conversion AS3 tentative:

public var useJSCalls:Boolean = true; 

    public function read(length):Array { 
     var i:int; 
     var j:int; 
     var ref; 
     var results:Array; 

     results = []; 
     var cur:int = file.position; 
     //var val = file.readUTFBytes(length); 
     //file.position = cur; 

     for (i = j = 0, ref = length; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) { 
      results.push(file.readUnsignedByte()); 
      //results.push(file.readByte()); 
      //results.push(file.readByte()); 
      //results.push(file.position++); 
      //results.push(data[position++]); 
     } 


     return results; 
    } 

    public function readString(length:int = -1):String { 
     if (useJSCalls) { 
      var val = read(length); 
      val = String.fromCharCode(val); 
      //val = String.fromCharCode(val).replace(/\u0000/g, ""); 
      return val; 
     } 

     if (length==-1) { 
      length = 1; 
     } 

     //var value = file.readMultiByte(length, "utf-8"); 
     var value = file.readMultiByte(length, "utf-8"); 

     return value; 
    } 

    public function readUnicodeString(length:int = -1):String { 
     var currentPosition:uint = file.position; 

     if (useJSCalls) { 
      if (length == -1) { 
       length = file.readInt(); 
      } 

      //return iconv.decode(new Buffer(this.read(length * 2)), 'utf-16be').replace(/\u0000/g, ""); 
      var array = read(length * 2); 
      var value = String.fromCharCode(array); 
      value = value.replace(/\u0000/g, ""); 
      var newPosition:uint = file.position; 
      file.position = currentPosition; 

      var value2 = file.readMultiByte(length, "utf-8"); 

      //value = file.readUTFBytes(int(length)); 
      file.position = newPosition; 

      return value; 
     } 

     return value; 
     /* 
     if (length==-1) { 
      return file.readInt() + ""; 
     } 

     return file.readUTFBytes(length); 
     */ 
    } 

Answer 1

Vérifiez la as3 doc of ByteArray

readUnicodeString() et readString() devrait être readUTFBytes()

Je ne pense pas que AS3 a LongIntegers, mais readDouble() devrait travailler pour que pour autant que je sais .

Answer 2

readUnicodeString

function readUnicodeString(source:ByteArray, length:* = null):String 
{ 
    if (isNaN(length)) length = source.readUnsignedInt(); 
    else if (length < 1) length = source.readUnsignedInt(); 

    return source.readMultiByte(length, "utf-16be"); 
} 

ReadString

// lit Vraisemblablement une chaîne non UTF (probablement ASCII).

function readString(source:ByteArray, length:uint):String 
{ 
    return source.readMultiByte(length, "ascii"); 
} 

readLongLong

En AS3, il existe deux types entiers, int et uint, 4 octets les deux, donc probaly ce sera quelque chose comme

function readLongLong(source:ByteArray):Number 
{ 
    var result:Number = 0; 

    result += source.readUnsignedInt(); 
    result += source.readUnsignedInt() << 32; 

    return result; 
} 

lecture

// Je pense toujours que le code original fait des choses plus simples qu'il n'y paraît.

function read(source:ByteArray, length:int):void 
{ 
    var result:Array = new Array; 

    for (var i:int = Math.abs(length); i > 0; i--) 
     result.push(source.readUnsignedByte()); 

    return result; 
} 

dire

Besoin d'un renseignement.