We're looking for a user researcher to understand the needs of developers and designers. Is this you or someone you know? Check out the post: https://mzl.la/2IGzdXS

Cette traduction est incomplète. Aidez à traduire cet article depuis l'anglais.

Debugger.Object

Une instace de Debugger.Object représente un objet du code débugué, fournissant des méthodes orientés reflection pour pouvoir inspecter et modifier son référent. Les proprotétées du référent n'apparaisent pas directement en tant que propriétées de l'instance de Debugger.Object. Le débogueur peut accéder à ces propriétées uniquement en passant par des méthodes comme Debugger.Object.prototype.getOwnPropertyDescriptor et Debugger.Object.prototype.defineProperty, cela afin d'être sur que le débogueur n'invoquera pas par érreur des getters et setters du référent.

SpiderMonkey crée exactement une instance de Debugger.Object par objet du code débogué présenté à une instance de Debugger : Si le débogueur rencontre le même objet en passant par deux chemins différents (par exemple si deux fonction sont appellé sur le même objet), SpiderMonkey présentera au débogueur la même instance de Debugger.Object à chaque fois. Cela signifie que le débogueur peut utiliser l'opérateur == pour reconaitre les moments ou deux instances de Debugger.Object font référence au même objet du code débogué (si instance == instance alors elles font référence au même objet). Le débogueur peut alors placer ses propres propriétes sur une instance de Debugger.Object pour stocker des méta-données sur un objet du code débogué en particulier.

Du code JavaScript dans diférents compartiments peut avoir diférentes visions du même objet. Par exemple dans Firefox, du code dans un compartiment priviilégié peut voir les objets des éléments DOM contenu sans les redifinitions ou extensions fait à aux propriétées de cet objet par du code contenu. (Dans la términolgie Firefox, le code privilégié voit les élément au travers d'un “xray wrapper”). Afin de s'assurer que le code du débogueur voit chaque objet comme le code débogué le verait, chaque instance de Debugger.Object présente son référent comme il serait vu depuis un compartiment particulier. Ce “viewing compartment” est chosi pour corespondre à la foçon dont le débogueur rencontre le référent. En conséquence, une seule instance de Debugger peut avoir en réalitée plusieurs instances de Debugger.Object : une par compartiment depuis lequel le référent est vu.

Si plus d'une instance de Debugger est en train de débouer le même code, chaque Debugger obtient une instance de Debugger.Object pour chaque objet donné. Cela permet au code utilisant chaque instance de Debugger de placer les propriétés qu'elle veut sur ses propres instance de Debugger.Object, cela sans avoir à s'inquiéter d'interferer avec d'autres débogueurs.

Tandis que la plupart des instances Debugger.Object sont crées SpiderMonkey dans processus d'exposition des comportements et états du code débogué au débogueur, le débogueur peut utiliser Debugger.Object.prototype.makeDebuggeeValue pour créer des instances de Debugger.Object pour un objet du code déboguer donné, ou utiliser Debugger.Object.prototype.copy et Debugger.Object.prototype.create pour créer de nouveaux objets dans les compartiment du code débogué, alloués comme elles l'auraient été par des gloables du code débogué.

Les instances de Debugger.Object protègent leurs référents du garbage collector. Aussi logntemps que l'instance de Debugger.Object est vivante, le référent l'est aussi. Cela veut dire que le garbage collection n'a pas d'effet visible sur les instances de Debugger.Object.


Propriétés d'accès du prototype de Debugger.Object

Une instance Debugger.Object hérite par son prototype des propriétés d'accès suivantes :

proto
Le prototype de référence (en tant que nouvelle instance Debugger.Object), ou null si il n'y a pas de prototype. Cet accésseur peut lever une exception si le référent est un script proxy ou un autre genre d'objet exotique (un wrapper opaque, par exemple).
class
Un chaine de caractère nommant la [[Class]] ECAMAScript du référent.
callable
true si le référent est un objet appellable (telle qu'une fonction ou un proxy de fonction). false sinon.
name

Le nom du référent, s'il s'agit d'une fonction avec un nom. Si le référent est une fonction anonyme, ou n'est pas une fonction appellable, vaut undefined.

Cet accésseur retourne le nom qui apparait après le mot clé function dans le code source, qu'importe si la fonction est le résultat de l'instantiation d'une déclaration de fonction (qui bind la fonction à son nom dans la portée englobante.) ou évalue un expression de fonction (qui bind la fonction à son nom uniquement dans le corps de la fonction).

displayName

Le nom d'affichage du référent, s'il s'agit d'une fonction avec un nom. Si le référent est une fonction anonyme, ou n'est pas une fonction du tout, vaut undefined.

Si une fonction a un nom donné, son nom d'affihcage est le même. Dans ce cas, les propriétésdisplayName et name sont égales.

Si une fonction n'a pas de nom, alots SpiderMonkey essaie d'inférer un nom approprié en fonction de son contexte, par exemple :

function f() {}          // displayName: f le nom de la fonction)
var g = function () {};  // displayName: g
o.p = function () {};    // displayName: o.p
var q = {
  r: function () {}      // displayName: q.r
};

Il est a noter que le nom d'affiche peut ne pas être un identifiant JavaScript valide. Nous essayons de trouver de snoms utiles lorsque la fonction n'a pas de valeur assigné directement. Ainsi, nous utilisons a/b pour fair référence au to b défini dans a, et a< pour faire référence à une fonction qui s'effecctue quelque part dans une expression assignée à a. Par exemple :

function h() {
  var i = function() {};    // displayName: h/i
  f(function () {});        // displayName: h/<
}
var s = f(function () {});  // displayName: s<
parameterNames

Si le référent est une fonction de débogue, les noms de ses paramètres, sous la forme d'un tableau de chaines de caractères. Si le référent n'est pas une fonction de débogue, o n'est pas une fonction du tout, alors cela vaut undefined.

Si le référent est fonction hôte pour laquelle les noms de paramètres ne sont pas dispobibles, alors retourne un tableau avec une élément par paramètre, chacun valant undefined.

Si le référent est fonciton proxy, retounre un tableau vide.

Si le référent utilise les paramètres déstrcuturés, alors les éléments du tableau suivent la structure des paramètres. Par exemple, si le référent est une fonction définie ainsi :

function f(a, [b, c], {d, e:f}) { ... }

Alors la propriétée parameterNames de cette instance Debugger.Object vaudra :

["a", ["b", "c"], {d:"d", e:"f"}]
script
Si le référent est une fonction de débogue, retourne le script de la fonction, en tant qu'instance de Debugger.Script. Si le référent n'es pas une fonction proxy, ou du code de débogue, retourne undefined.
environment
Si le référent est une fonction de débogue, retourne une instance Debugger.Environment représentant l'environement lexical, de la fonction englobante lors de sa création. Si le référent n'es pas une fonction proxy, ou du code de débogue, retourne undefined.
errorMessageName
Si le référent est une erreur crée avec un template de message moteur interne, retourne un chaine de caractère valant ne nom du template. Retourne undefined sinon.
errorLineNumber
Si le référent est un objet Error, vaut le numéro de ligne à laquelle le référent a été crée. Retourne undefined sinon.
errorColumnNumber
Si le référent est un objet Error, retourne le numéro de colone, à laquelle le référent a été crée. Retourne undefined sinon.
isBoundFunction
Si le référent est une fonction de débogue, retourne true si le référent est une fonction liée (bound function); retourne false sinon. Si le référent n'est pas une fonction de débogue, ou n'est pas une fonction du tout, retourne undefined à la place.
isArrowFunction
Si le référent est un debuggee function, retournes true Si le référent est une arrow function; retourne false sinon. Si le référent n'est pas une fonction de débogue, ou n'est pas une fonction du tout, retourne undefined.
isGeneratorFunction
Si le référent est une fonction de débogue, retourne true si le référent a été crée avec une expression function*.  Ou faux sinon si il s'agit d'un autre type de fonction. Si le référent n'est pas une fonction de débogue, ou n'est pas une fonction du tout, retourne undefined. (Vaut toujours la même chose que obj.script.isGeneratorFunction, si obj.script est un Debugger.Script.)
isAsyncFunction
Si le référent est une fonction de débogue retourne true si le référent est une fonction async, définie avec une expression async function, ou faux, si il s'agit d'un autre type de fonction. Si le référent n'est pas une fonction de débogue, ou n'est pas une fonction du tout, retourne undefined. (Vaut toujours la même chose que obj.script.isAsyncFunction, si obj.script est un Debugger.Script.)
isPromise
true Si le référent est une Promise; false sinon.
boundTargetFunction
Si le référent est une fonction de débogue liée (bound debuggee function), retounre sa fonction cible - la fonction liée à un objet this en particulier. Si le référent n'est ni une fonction liée, ni une fonction de débogue, ou n'est pas une fonction du tout, retourne undefined.
boundThis
Si le référent est une fonction liée, retourne la valeur this liée. Si le référent n'est ni une fonction liée, ni une fonction de débogue, ou n'est pas une fonction du tout, retourne undefined.
boundArguments
Si le référent est une fonction liée, retourne un tableau (dans le compartiment de l'objet Debugger) qui contient les valeur de l'objet arguments lié. object. Si le référent n'est ni une fonction liée, ni une fonction de débogue, ou n'est pas une fonction du tout, retourne undefined.
isProxy
Si le référent est un proxy (scripté), révoqué ou non, retourne true. Si le référent n'est pas un proxy (scripté), retourne false.
proxyTarget
Si le référent est un proxy (scripté) non-révoqué, retourne une instance Debugger.Object faisant référence au [[ProxyTarget]] ECMAScript du le référent. Si le référent est un proxy (scripté) révoqué, retourne null. Si le référent n'est pas un proxy (scripté), retourne undefined.
proxyHandler
Si le référent est un proxy (scripté) non-révoqué, retourne une instance Debugger.Object faisant référence au [[ProxyHandler]] ECMAScript du le référent. Si le référent est un proxy (scripté) révoqué, retourne null. Si le référent n'est pas un proxy (scripté), retourne undefined.
promiseState

Si le référent est une Promise, retourne une chaine de caractères indiquant si la Promise est en cours, ou a été complétée ou rejetée. Cette chaine peut prendre les valeur suivantes :

  • "pending", si la Promise est en cours.

  • "fulfilled", si la Promise a été complétée

  • "rejected", si la Promise a été rejetée

Si le référent n'est pas une Promise, lève un TypeError.

promiseValue

Retourne une valeur de débogue représentant la valeur avec laquelle la  Promise a été complétée.

Si le référent n'est pas une Promise, ou que la Promise n'a pas été complétée, lève un TypeError.

promiseReason

 

Retourne une valeur de débogue représentant la valeur avec laquelle la  Promise a été rejetée.

Si le référent n'est pas une Promise, ou que la Promise n'a pas été rejetée, lève un TypeError.

 

promiseAllocationSite
Si le référent est une Promise, il s'agit de la pile d'exécution JavaScript capturé au moment de l'allocation de la promise. Peut retourner null si la promise n'a pas été crée depuis un script. Si le référent n'est pas une Promise, lève une exception TypeError.
promiseResolutionSite
Si le référent est une Promise, il s'agit de la pile d'exécution JavaScript capturé au moment de l'allocation de la promise. Peut retourner null si la promise n'a pas été résolue en appellant ses fonctions resolve ou  reject depuis un script. Si le référent n'est pas une Promise, lève une exception TypeError.
promiseID
Si le référent est une Promise, retourne un indentifiant unique au processus pour la Promise. Avec e10s, le même id peut être assigné à plusieurs instances Promise, si ces instances ont été crées par différents processus. Si le référent n'est pas une Promise, lève une exception TypeError.
promiseDependentPromises
Si le référent est une Promise, retourne un tableau de Debugger.Objects faisant références aux promise dépendant directement de la promise de référence. Celles ci sont :
  1. retourne les valeurs des appels then() de la promise.
  2. retourne les valeurs de Promise.all() si la promise de référence a été passé comme un de ces arguments.
  3. retourne les valeurs de Promise.race() Si la promise de référence Promise a été passée comme un de ces arguments.

Une fois qu'une Promise est finie, elle notifiera généralement les promises dépendantes, et les oublie ensuite, c'est donc plus utilie sur les promises en cours d'exécution.

Il est à noter que le tableau de retour ne contient que les promises qui sont direcement dépendantes de la promis ede référence. Il ne contient pas les promises qui dépendent de promise qui dépendent de la promise de référence.

Si le référent n'est pas une Promise, lève exception TypeError.

promiseLifetime
Si le référent est une Promise, retourne le nombre de millisecondes pasées depuis la création de Promise. Si le référent n'est pas une Promise, lève une exception TypeError.
promiseTimeToResolution
Si le référent est une Promise, retourne le nombre de millisecondes pasées entre la création de Promise et sa résolution. Si le référent n'est pas une Promise, lève une exception TypeError.
global
Retourne une instance Debugger.Object faisant référence à l'objet global du scope ou le référent a été alloué. Cela ne droule pas les cross-compartment wrappers : Si le référent est un wrapper, le resultat fait référance à l'objet gloabal du wrapper, pas à lobjet gloabal auquel le wrapper fait référence. Le résultat du retour fait référence à l'objet gloabl directement, et pas via un wrapper.
allocationSite
Si la trauqe des sites d'allocation de l'objet a été activé lorsque l'instance Debugger.Object du référent, retourne la pile d'execution JavaScript capturée au moment de l'allocation. Retourne null.

Function Properties of the Debugger.Object prototype

The functions described below may only be called with a this value referring to a Debugger.Object instance; they may not be used as methods of other kinds of objects. The descriptions use “referent” to mean “le référent of this Debugger.Object instance”.

Unless sinon specified, these methods are not invocation functions; if a call would cause debuggee code to run (say, because it gets or sets an accessor property whose handler is debuggee code, or because le référent is a proxy whose traps are debuggee code), the call throws a Debugger.DebuggeeWouldRun exception.

These methods may throw Si le référent n'est pas a native object. Even simple accessors like isExtensible may throw Si le référent est un proxy or some sort of exotic object like an opaque wrapper.

getProperty(name)
retourne the value of le référent’s property namedname, or undefined if it has no such property.Name must be a string. The result is a debuggee value.
setProperty(name,value)
Storevalue as the value of le référent’s property namedname, creating the property if it does not exist.Name must be a string;value must be a debuggee value.
getOwnPropertyDescriptor(name)
retourne a property descriptor for the property namedname of le référent. If le référent has no such property, retourne undefined. (This function behaves like the standard Object.getOwnPropertyDescriptor function, except that the object being inspected is implicit; the property descriptor retourneed is allocated as if by code scoped to the debugger’s global object (and is thus in the debugger’s compartment); and its value, get, and set properties, if present, are debuggee values.)
getOwnPropertyNames()
retourne an array of strings naming all le référent’s own properties, as if Object.getOwnPropertyNames(referent) had been called in the debuggee, and the result copied in the scope of the debugger’s global object.
getOwnPropertySymbols()
retourne an array of strings naming all le référent’s own symbols, as if Object.getOwnPropertySymbols(referent) had been called in the debuggee, and the result copied in the scope of the debugger’s global object.
defineProperty(name,attributes)
Define a property on le référent namedname, as described by the property descriptordescriptor. Any value, get, and set properties ofattributes must be debuggee values. (This function behaves like Object.defineProperty, except that the target object is implicit, and in a different compartment from the function and descriptor.)
defineProperties(properties)
Add the properties given byproperties to le référent. (This function behaves like Object.defineProperties, except that the target object is implicit, and in a different compartment from theproperties argument.)
deleteProperty(name)
Remove le référent’s property namedname. retourne true if the property was successfully removed, or if le référent has no such property. retourne false if the property is non-configurable.
seal()
Prevent properties from being added to or deleted from le référent. retourne this Debugger.Object instance. (This function behaves like the standard Object.seal function, except that the object to be sealed is implicit and in a different compartment from the caller.)
freeze()
Prevent properties from being added to or deleted from le référent, and mark each property as non-writable. retourne this Debugger.Object instance. (This function behaves like the standard Object.freeze function, except that the object to be sealed is implicit and in a different compartment from the caller.)
preventExtensions()
Prevent properties from being added to le référent. (This function behaves like the standard Object.preventExtensions function, except that the object to operate on is implicit and in a different compartment from the caller.)
isSealed()
retourne true if le référent is sealed—that is, if it is not extensible, and all its properties have been marked as non-configurable. (This function behaves like the standard Object.isSealed function, except that the object inspected is implicit and in a different compartment from the caller.)
isFrozen()
retourne true if le référent is frozen—that is, if it is not extensible, and all its properties have been marked as non-configurable and read-only. (This function behaves like the standard Object.isFrozen function, except that the object inspected is implicit and in a different compartment from the caller.)
isExtensible()
retourne true if le référent is extensible—that is, if it can have new properties defined on it. (This function behaves like the standard Object.isExtensible function, except that the object inspected is implicit and in a different compartment from the caller.)
copy(value)

Apply the HTML5 “structured cloning” algorithm to create a copy ofvalue in le référent’s global object (and thus in le référent’s compartment), and retourne a Debugger.Object instance referring to the copy.

Note that this retourne primitive values unchanged. This means you can use Debugger.Object.prototype.copy as a generic “debugger value to debuggee value” conversion function—within the limitations of the “structured cloning” algorithm.

create(prototype, [properties])
Create a new object in le référent’s global (and thus in le référent’s compartment), and retourne a Debugger.Object referring to it. The new object’s prototype isprototype, which must be an Debugger.Object instance. The new object’s properties are as given byproperties, as ifproperties were passed to Debugger.Object.prototype.defineProperties, with the new Debugger.Object instance as the this value.
makeDebuggeeValue(value)

retourne the debuggee value that representsvalue in the debuggee. Ifvalue is a primitive, we retourne it unchanged; ifvalue is an object, we retourne the Debugger.Object instance representing that object, wrapped appropriately for use in this Debugger.Object’s referent’s compartment.

Note that, ifvalue is an object, it need not be one allocated in a debuggee global, nor even a debuggee compartment; it can be any object the debugger wishes to use as a debuggee value.

As described above, each Debugger.Object instance presents its referent as viewed from a particular compartment. Given a Debugger.Object instanced and an objecto, the call d.makeDebuggeeValue(o) retourne a Debugger.Object instance that presentso as it would be seen by code ind’s compartment.

decompile([pretty])
Si le référent est une fonction de débogue, retourne the JavaScript source code for a function definition equivalent to le référent function in its effect and result, as a string. Ifpretty is present and true, produce indented code with line breaks. Si le référent n'est pas a function that is debuggee code, retourne undefined.
call(this,argument, …)
If le référent is callable, call it with the giventhis value andargument values, and retourne a completion value describing how the call completed.This should be a debuggee value, or { asConstructor: true } to invoke le référent as a constructor, in which case SpiderMonkey provides an appropriate this value itself. Eachargument must be a debuggee value. All extant handler methods, breakpoints, and so on remain active during the call. Si le référent n'est pas callable, throw a TypeError. This function follows the invocation function conventions.
apply(this,arguments)
If le référent is callable, call it with the giventhis value and the argument values inarguments, and retourne a completion value describing how the call completed.This should be a debuggee value, or { asConstructor: true } to invokefunction as a constructor, in which case SpiderMonkey provides an appropriate this value itself.Arguments must either be an array (in the debugger) of debuggee values, or null or undefined, which are treated as an empty array. All extant handler methods, breakpoints, and so on remain active during the call. Si le référent n'est pas callable, throw a TypeError. This function follows the invocation function conventions.
executeInGlobal(code, [options])

Si le référent est un global object, evaluatecode in that global environment, and retourne a completion value describing how it completed.Code is a string. All extant handler methods, breakpoints, and so on remain active during the call. This function follows the invocation function conventions. Si le référent n'est pas a global object, throw a TypeError exception.

Codeis interpreted as strict mode code when it contains a Use Strict Directive.

This evaluation is semantically equivalent to executing statements at the global level, not an indirect eval. Regardless ofcode being strict mode code, variable declarations incode affect le référent global object.

Theoptions argument is as for Debugger.Frame.prototype.eval.

executeInGlobalWithBindings(code,bindings, [options])

Like executeInGlobal, but evaluatecode using le référent as the variable object, but with a lexical environment extended with bindings from the objectbindings. For each own enumerable property ofbindings namedname whose value isvalue, include a variable in the lexical environment in whichcode is evaluated namedname, whose value isvalue. Eachvalue must be a debuggee value. (This is not like a with statement:code may access, assign to, and delete the introduced bindings without having any effect on thebindings object.)

This method allows debugger code to introduce temporary bindings that are visible to the given debuggee code and which refer to debugger-held debuggee values, and do so without mutating any existing debuggee environment.

Note that, like executeInGlobal, any declarations it contains affect le référent global object, even ascode is evaluated in an environment extended according tobindings. (In the terms used by the ECMAScript specification, the VariableEnvironment of the execution context forcode is le référent, and thebindings appear in a new declarative environment, which is the eval code’s LexicalEnvironment.)

Theoptions argument is as for Debugger.Frame.prototype.eval.

asEnvironment()
Si le référent est un global object, retourne the Debugger.Environment instance representing le référent’s global lexical scope. The global lexical scope’s enclosing scope is the global object. Si le référent n'est pas a global object, throw a TypeError.
unwrap()
Si le référent est un wrapper that this Debugger.Object’s compartment is permitted to unwrap, retourne a Debugger.Object instance referring to the wrapped object. If we are not permitted to unwrap le référent, retourne null. Si le référent n'est pas a wrapper, retourne this Debugger.Object instance unchanged.
unsafeDereference()

retourne le référent of this Debugger.Object instance.

Si le référent est unn inner object (say, an HTML5 Window object), retourne the corresponding outer object (say, the HTML5 WindowProxy object). This makes unsafeDereference more useful in producing values appropriate for direct use by debuggee code, without using invocation functions.

This method pierces the membrane of Debugger.Object instances meant to protect debugger code from debuggee code, and allows debugger code to access debuggee objects through the standard cross-compartment wrappers, rather than via Debugger.Object’s reflection-oriented interfaces. This method makes it easier to gradually adapt large code bases to this Debugger API: adapted portions of the code can use Debugger.Object instances, but use this method to pass direct object references to code that has not yet been updated.

forceLexicalInitializationByName(binding)
Ifbinding is in an uninitialized state initialize it to undefined and retourne true, sinon do nothing and retourne false.

Source Metadata

Generated from file:
 
js/src/doc/Debugger/Debugger.Object.md
Watermark:
sha256:7ae16a834e0883a95b4e0d227193293f6b6e4e4dd812c2570372a39c4c04897b
Changeset:
5572465c08a9+

Étiquettes et contributeurs liés au document

Contributeurs à cette page : maximelore
Dernière mise à jour par : maximelore,