La création d'une coutume trace() de la classe en AS3

trace() lui-même est une fonction de haut niveau, pas une classe, donc, malheureusement, nous ne pouvons pas nous étendre. Cela étant dit, nous pouvons l'utiliser dans une classe simple de faire exactement ce qu'il fait normalement, seulement dans ce cas, la trace est basée sur des conditions (c'est à dire Boolean - true|false, etc). Nous avons d'abord créer la Trace de la classe, ce qui nous n'aurions pas instancier nous parce que nous sommes en utilisant une Usine modèle de conception par le biais de la classe ci-dessous, Traceur. Traceur est construit autour du modèle de conception singleton, mais utilise le modèle de Fabrique pour instancier les instances de Trace, lorsque la méthode trace de Traceur est appelé.

//This class is handled by Tracer, which is right below it.
//You WILL NOT instantiate these, nor hold references.
package
{
public class Trace
{
private function _value:*;
private function _trace:Boolean;
public function Trace(pValue:*, pTrace:Boolean):void
{
_value = pValue;
_trace = pTrace;
}
public function get value():*
{
return _value;
}
public function get trace():Boolean
{
return _trace;
}
}
}
//This is the important class and the only one you will work with.
package
{
/**
*Utilizes Singleton and Factory design patterns.
*/
public class Tracer
{
private var _traceArray:Array;
private static var _instance:Tracer;
public function Tracer(pvt:PrivateClass = null):void
{
if(pvt == null)
{
throw(new Error("You cannot instantiate this class directly, please use the static getInstance method."));
}
_init();
}
public static function getInstance():Tracer
{
if(Tracer._instance == null)
{
Tracer._instance = new Tracer(new PrivateClass());
}
return Tracer._instance;
}
public function trace(pValue:*, pTrace:Boolean):void
{
var trace:Trace = new Trace(pValue, pTrace);
if(trace.pTrace)
{
trace(pValue);
}
}
//Since we have the option for individual traces to be disabled
//I provide this to get access to any and all later.
public function traceAll():void
{
traceStr:String = _traceArray.toString();
}
public function get traceables():Array
{
return _traceArray;
}
//Here we provide a method to trace all, even if set to false in their constructor.
private function _init():void
{
_traceArray = new Array();
}
}
}
//Here we create a class that is OUTSIDE of the package.
//It can only be accessed from within this class file.  We use this
//to make sure this class isn't instantiated directly.
class PrivateClass
{
function PrivateClass():void
{
trace('can only be accessed from within this class file');
}
}
//Now for use in doc class
package
{
import flash.display.Sprite;
import flash.events.Event;
//No need to import Tracer and Trace, they are also in the
//unnamed package.
public class DocumentClass extends Sprite
{
private var _tracer:Tracer;
public function DocumentClass():void
{
if(stage) _init();
else addEventListener(Event.ADDED_TO_STAGE, _init);
}
private function _init(e:Event = null):void
{
_tracer = Tracer.getInstance();
_tracer.trace(10*20, false);
_tracer.trace(10*20, 0); //SAME AS ABOVE
_tracer.trace("I love AS3", true); //traces
_tracer.traceAll(); //Would trace: 200, 200, I love AS3
}
}
}

Garder à l'esprit que c'est au large de la hanche et pourrait très bien avoir un bug ou deux, mais l'idée est là; C'est-à-dire que ce n'est pas testé, c'est simplement pour vous donner une idée de la façon dont vous pourriez le mettre en œuvre.

J'espère que cette aide.

OriginalL'auteur Brian Hodge

Regarder le Flex la journalisation API, en particulier la section: la mise en Œuvre d'une coutume logger avec l'API de journalisation.

Chercher le TraceTarget classe.

OriginalL'auteur dirkgently

Ici est super simple trace personnalisé fonction que j'utilise. debugFlag peut être défini à true/false
ailleurs dans le package.

public static function myTrace(... vars) :void {

if (debugFlag) {
var output:Array = new Array;
for each (var arg in vars) {
output.push(arg);
}
trace(output);
} 

}

OriginalL'auteur

Trace est une fonction de haut niveau, de sorte que vous ne pouvez pas le remplacer, et autant que je sache, il ne déclenche pas tous les événements. Puisque c'est une fonction de haut niveau (qui n'est pas contenue dans un nom de paquet), vous pouvez l'utiliser sans déclarations d'importation.

Voici un exemple d'un haut niveau de "Traceur" de classe que vous pouvez utiliser à la place de trace, sans déclarations d'importation.

Appelez simplement de "Traceur.écrire" ou de "Traceur.writeError" pour le traçage des objets d'Erreur.
"Traceur.écrire" accepte un nombre variable d'arguments, tout comme le construit en fonction de trace. "Traceur.writeError" est une méthode d'assistance qui vous permet de trouver facilement les objets d'Erreur.

Caractéristiques:

1. Appels intégré trace.
2. Garde un journal de vos appels à Tracer.écrire comme un tableau de chaînes de caractères.
3. Le journal des appels est accessible comme une chaîne de caractères par getText, qui relie tous les éléments du tableau avec un caractère de saut de ligne et éventuellement virer de bord sur les numéros de ligne!
4. Déclenche des événements lors de l'ajout de nouvelles lignes dans le journal, donc si vous avez une sorte de fenêtre d'affichage pour le journal, la fenêtre d'affichage peut écouter pour Traceur événements pour mettre à jour l'affichage en temps réel de tous les événements se produisent. Ce qui est excellent pour l'affichage des événements de trace lors de l'exécution à l'intérieur d'un navigateur web ou un lecteur autonome.

-Tracer la définition de la classe

package
{
import flash.events.EventDispatcher;
public class Tracer extends EventDispatcher
{
private static var traced_text:Array = new Array( "--Start of Trace Log--" );
public static var enabled:Boolean = true;
private static var suspended:Boolean = false;
public static var instance:Tracer = new Tracer();
public static const newline:String = "\n"; //workaround for TextField.appendText bug.. use "\n" instead of "\r".  See note and link to bug post in getText method
public function Tracer()
{
}
static public function write( ...args ):void
{
if (enabled && !suspended)
{
trace.apply( null, args );
var text:String = args.join( newline );
var next_index:int = traced_text.length;
traced_text.push( text );
suspended = true; //prevent recursive calls from TracerEvent handler
instance.dispatchEvent( new TracerEvent( text, next_index ) );
suspended = false;
}
}
static public function writeError( e:Error ):void
{
write( "errorID: " + e.errorID, "errorName: " + e.name, "errorMessage: " + e.message, "stackTrace: " + e.getStackTrace() );
}
static public function getText( include_line_numbers:Boolean ):String
{
var line_count:int = traced_text.length;
var lines:Array = traced_text; //store pointer to traced_text; pointer may be changed to reference an altered array that includes line numbers
if (include_line_numbers) //create temporary trace log copy with altered lines; allows quick call to join at end
{
var new_lines:Array = new Array();
for (var i:int = 0; i < line_count; i++)
new_lines.push( i.toString() + ": " + lines[i] );
lines = new_lines;
}
return lines.join( newline ); //do not include last newline character (workaround for bug in appendText method (https://bugs.adobe.com/jira/browse/FP-1982); I have to call appendText with newline character first, otherwise it has issues like not acknoledging the newline thats already there at the end).
}
static public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void 
{
instance.addEventListener(type, listener, useCapture, priority, useWeakReference);
}
static public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void 
{
instance.removeEventListener(type, listener, useCapture);
}
static public function willTrigger(type:String):Boolean 
{
return instance.willTrigger(type);
}
static public function hasEventListener(type:String):Boolean 
{
return instance.hasEventListener(type);
}
}
}

-TracerEvent définition de la classe

package
{
import flash.events.Event;
public class TracerEvent extends Event
{
public static const WRITE:String = "te_write";
public var text:String;
public var index:int; //index of newly traced text in the traced_text array (trace log)
public function TracerEvent( text:String, index:int ) 
{
super( WRITE, false, false );
this.text = text;
this.index = index;
}
override public function clone():Event 
{
return new TracerEvent( text, index );
}
}
}

OriginalL'auteur Triynko

vous n'avez pas besoin de le remplacer , il suffit de créer une fonction dans votre projet et appel il trace ensuite toute trace appel point à ce.trace 😉

function trace(... arguments){  
yourfunction(arguments);
}

OriginalL'auteur Fareed Alnamrouti