mozilla
Vos résultats de recherche

    Référence de JSAPI

    Ce document est en cours de traduction vers le français. C'est la raison pour laquelle il est en partie dans une autre langue.
    N'hésitez pas à vous inscrire et à nous aider à traduire le MDN!

    JSAPI est l'implémentation en C du moteur JavaScript SpiderMonkey. Pour apprendre à utiliser JSAPI, lisez le Guide utilisateur JSAPI [en] et le JSAPI Cookbook [en].

    Note : La page wiki consacrée à FOSS [en] présente plusieurs liens vers différents outils et librarires pour faciliter l'utilisation quotidienne de SpiderMonkey et JSAPI.
    Note de traduction : l'essentiel des liens présentées ici ciblent des ressources en anglais. Le livre de référence de JSAPI étant en cours de traduction, les liens menant vers des ressources traduites en français seront suffixées du symbole [fr].

    Runtimes et contextes

    • Options: JSOPTION_STRICT, JSOPTION_WERROR, JSOPTION_VAROBJFIX, JSOPTION_COMPILE_N_GO, JSOPTION_ATLINE, JSOPTION_XML, JSOPTION_RELIMIT, JSOPTION_NO_SCRIPT_RVAL, JSOPTION_UNROOTED_GLOBAL, JSOPTION_METHODJIT, JSOPTION_PROFILING, JSOPTION_METHODJIT_ALWAYS, JSOPTION_PCCOUNT, JSOPTION_TYPE_INFERENCE, JSOPTION_SOFTEN
    • JS_GetOptions
    • JS_SetOptions
    • JS_ToggleOptions

    Compartiments :

    Méthodes de locales :

    Types de méthodes de locales :

    Scripts

    Exécution simple de code JavaScript :

    Exécution compilée de code JavaScript dans un objet JSScript exécutable à la volée :

    Compilation de code JavaScript dans une fonction :

    Gestion des erreurs

    Méthodes C/C++ de levée et de capture d'exceptions JavaScript :

    Fonctions de conversion d'erreur JavaScript en exceptions (et inversement) :

    Types et valeurs

    Constantes jsval :

    Fonctions et macros de détermination de types jsval:

    Méthodes haut-niveau de conversion de types pour l'encapsulation/désencapsulation d'arguments de fonctions.

    Conversions de types JavaScript. Ces méthodes peuvent être appliquées à n'importe-quel type de variable jsvals. Elles peuvent potentiellement retourner des objets. Par exemple, JS_ValueToObject(cx, s)s est une chaîne de caractères renvoie un nouvel objet de type String. Ces fonctions peuvent appeler des méthodes JavaScript. Par exemple, JS_ValueToString(cx, obj) peut appeler obj.toString().

    Macros à éxecution rapide sans contrôle de type. Ces macros ne doivent pas être appliquées à des valeurs dont le type n'est pas précisément connu au départ. Comme les 'casts' C, elles peuvent planter l'éxecution si elles sont appliquées à des types/valeurs incorrectes. Elles ne renvoient jamais d'objet et n'appellent jamais de code JavaScript directement.

    Function de retour de type (équivalent à typeof) :

    Functions de comparaison :

    Gestion de la mémoire

    Ces fonctions se comportent comme les méthodes C Standard de type malloc, à l'exception des erreurs qui sont rapportées via les APIs de gestion d'erreur de SPiderMonkey plutôt que via errno. Ces fonctions autorisent également SpiderMonkey à contrôler la quantité de bits alloués en mémoire :

    Objets JavaScripts, chaînes de caractères, et nombres à virgule flottante sont gérés par le ramasse-miette. Ces fonctions permettent d'accéder à la gestion du ramasse-miette :

    Le reste de ces APIs permet de protéger les objets en mémoire de leur destruction par le ramasse-miette avant que l'application n'ai cessé de les utiliser.

    Si une variable est racine (root), tout élément pointé en référence par cette variable ne sera pas collectée par le ramasse-miette. Des erreurs dans la gestion des variables racines sont une cause fréquente de plantages inexpliqués difficiles à détecter.

    L'utilisation de portées locales des variables racines sont une autre méthode de prévenir les objets du passage du ramasse-miette.

    Added in SpiderMonkey 1.8 Si un objet contient des références vers d'autres éléments dans le ramasse-miette qui ne sont pas stockés bia le moteur de structure de données (slots) de SpiderMonkey, il doit implémenter la méthode JSTraceOp pour permettre au ramasse-miette de traverser ses objets référencés. Autrement, le ramasse-miette ne pourra pas détecter et collecter les objets potentiellement éligibles, provoquant un plantage. (Dans SpiderMonkey 1.7 et antérieur, la méthode JSMarkOp est utilisée. Cette méthode est notée deprecated dans la version 1.8 de SpiderMonkey à venir.)

    Les APIs de traçage sont utilisées par le ramasse-miette et la méthode JSMarkOp. Les applications JSAPI peuvent également les utiliser pour examiner le contenu des objets. (Par exemple, ces APIs procurent une interaction fine entre le ramasse-miette JavaScript et les autres types de ramasse-miette.)

    APIs du ramasse-miette diverses :

    Numbers

    Strings

    Interning strings tells the SpiderMonkey engine to reuse existing string objects when possible.

    The character data for external strings is stored in memory provided by the application. Applications can use this to avoid copying data back and forth between SpiderMonkey's heap and application memory.

    Objects

    Date

    Properties

    These functions correspond directly to the ways scripts access object properties:

    The following functions are lower-level, allowing the JSAPI application more access to details of how properties are implemented. "Define" is a lower-level version of "set" that provides access to extra settings and does not call setters. Similarly, "lookup" is a lower-level version of "get" that offers extra options and does not call getters.

    The following functions behave like JS_GetProperty and JS_GetPropertyById except when operating on E4X XML objects.

    A SpiderMonkey extension allows a native function to return an lvalue—that is, a reference to a property of an object:

    A jsid is kind of like a jsval, only different. A handful of APIs use jsids instead of jsvals for property names: JS_CheckAccess, JS_Enumerate, JS_GetMethodById, and JS_NextProperty.

    jsid constants:

    Function and macros for checking the type of a jsid:

    Classes

    These API features are used to define custom classes—object types that are implemented in C/C++ code but accessible from JavaScript.

    Adding native properties and methods to classes:

    JSFastNative methods use these macros: Added in SpiderMonkey 1.8

    The behavior of a JSClass and its instances can be customized in many ways using callback functions.

    JSClass method types:

    JSExtendedClass method types:

    JSObjectOps method types:

    JSXMLObjectOps method types:

    These stub functions can be used when creating a custom JSClass:

    The behavior of a JSClass can be customized using these flags:

    Arrays

    Functions

    Calling a function or a method of an object:

    Function accessors:

    Creating functions:

    RegExps

    Serialization

    • struct JSStructuredCloneCallbacks, JS_SetStructuredCloneCallbacks
    • JS_ReadStructuredClone, JS_WriteStructuredClone
    • JS_StructuredClone
    • JS_ReadUint32Pair, JS_ReadBytes, JS_WriteUint32Pair, JS_WriteBytes

    Security

    Added in SpiderMonkey 1.8.1 Security callbacks can be set per-runtime or per-context.

    Threading

    The following functions support the SpiderMonkey threading model.

    Note: JS_THREADSAFE is now permanently on.

    JSAPI 1.7 and earlier They are only available in JS_THREADSAFE builds.

    Added in SpiderMonkey 1.8 These functions are always available, but in non-JS_THREADSAFE builds, they do nothing.

    The following functions are always available, but in non-JS_THREADSAFE builds, they do nothing:

    Time

    Callback Types

    Native function types:

    Other callback types:

    See also Classes, above.

    Macros

    C++ features

    Tracing and debugging

    Étiquettes et contributeurs liés au document

    Contributors to this page:
    Dernière mise à jour par : teoli,