JavaScript引擎SpiderMonkey怎么用

這篇文章給大家分享的是有關JavaScript引擎SpiderMonkey怎么用的內容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

JavaScript是由Netscape開發的對象腳本語言，其特點是開發簡單、功能靈活，目前已廣泛應用于WEB頁面及服務器應用程序中。HTML本身是靜態的、不允許用戶干預，但用JavaScript編寫的腳本程序就可以在用戶的瀏覽器端運行，可以同用戶進行交互，從而實現動態頁面。可以將JavaScript與嵌入WEB的大多數對象的事件（如鼠標點擊、移動等）相關聯，然后用自己的方式處理這些事件。JavaScript提供了豐富的內置函數及命令，能在瀏覽器中顯示HTML、數值計算、多媒體播放、超級鏈接以及簡單的交互窗口等，還可以使在瀏覽器中運行的小Java應用程序的性質改變從而很容易地改變控件或其它對象的行為而不必深入研究其本身的結構。

JavaScript雖然是為Internet而開發的，但它的應用卻不僅僅局限于Internet，事實上由于其面向對象的特性使得其適用范圍非常廣泛，只要我們的應用程序具有良好的對象機制，我們就可以借用JavaScript，從而實現很好的交互功能。

SpiderMonkey是由C語言操作的JavaScript引擎，它支持JS1.4和ECMAScript-262規范。該引擎分析、編譯和執行腳本，根據JS數據類型和對象的需要進行內存分配及釋放操作。利用該引擎可以讓你的應用程序具有解釋JavaScript腳本的能力，目前已有若干個項目都采用了SpiderMonkey引擎，像K-3D、WebCrossing、WebMerger等。K-3D是用C++實現的3D建模與仿真系統，該系統內嵌SpiderMonkey引擎來提供自定義腳本（用戶創建腳本生成像齒輪一樣具有重復特性的復雜形體），也可用來驅動交互式的教學系統（用戶可以使用一段JS腳本程序記錄其交互過程，如移動鼠標、選擇菜單、點擊鼠標等）。WebCrossing利用SpiderMonkey實現了服務器端的腳本環境，提供了完全的Web-server腳本環境，服務器端的實現允許你在內置的、面向對象的數據庫中創建永久對象，這樣即可根據自己的需要擴展服務器環境。

在自己的應用程序中如何使用SpiderMonkey，最后給出一個簡單的例子程序。

如何使用引擎

JS引擎一般作為共享庫使用，應用程序調用引擎提供的API函數。引擎API函數大致分為以下幾種：數據類型操作、RunTime控制、類與對象的創建和維護、函數與腳本執行、字符串操作、錯誤處理、安全控制、Debug支持。 一般情況下，在你的應用程序中只需使用某幾類函數。例如，在進行JS調用之前你必須調用JS_NewRuntime函數來創建并初始化JS引擎。有些類型的函數，象安全控制類，提供可選擇的特征。

從概念上講，JS引擎是你系統上的一個共享資源。通過將引擎API調用嵌入到應用程序中（包含jsapi.h文件），你可以請求JS引擎進行操作。接下來，引擎處理你的請求，并將結果或狀態信息返回給你的應用程序。

例如，假定你在使用JS引擎自動化應用程序，腳本應用程序鑒別用戶并設置權限。首先，應用程序創建JS對象，該對象描述用戶信息，包括姓名、ID、權限和可用的函數列表。在這種情況下，應用程序首先調用JS_NewObject創建對象。當JS引擎創建對象后，返回一個指針給應用程序。應用程序再調用JS引擎執行腳本。在創建用戶對象后，應用程序即刻傳遞腳本給JS_EvaluateScript以便編譯和運行。腳本或許取得并效驗用戶信息，然后建立用戶存取的權利。

JS引擎收到初始化請求后，給JS RunTime分配內存，應用程序使用的變量、對象和上下文（上下文）都保存在RunTime中。一個上下文是腳本的執行狀態（JS引擎使用的）。每個同時存在的腳本或線程都必須有自己的上下文。單個的JS RunTime可以包含多個上下文、對象和變量。 幾乎所有的JS引擎調用都需要一個上下文變量，應用程序在創建RunTime后，首先應調用至少一次JS_NewContext來創建一個上下文。上下文的實際數量依賴于程序中同時使用的腳本數。程序中每個同時存在的腳本都需要一個上下文。另一方面，如果某個時刻只有一個腳本編譯和運行，那么你只需一個上下文給每個腳本重復使用即可。

在創建上下文后，要調用JS_InitStandardClasses初始化引擎中的內置JS對象，包括Array、Boolean、Date、Math、Number和String。 即使在創建對象時傳遞一個特定的上下文給JS引擎，這個對象在RunTime中也是獨立于上下文。任意腳本能與任意上下文建立聯系以便存取任意對象。腳本、上下文相互之間完全獨立，即使它們存取同樣的對象。在給定的RunTime中，應用程序能用未指定的上下文存取任意對象。你可以創建獨立的RunTime，一個用于共享上下文和對象，其余的用于私有上下文和對象。但注意，某個時刻只有一個線程能存取特定的上下文。
要讓應用程序能識別JS，嵌入適當的引擎調用到你的程序中。大致有以下幾個方面：

1. 程序中包含jsapi.h。

2. 程序中提供結構和變量聲明。例如，如果你計劃傳遞一個腳本給JS引擎，提供一個腳本字符串變量。用jsapi.h中定義的JS數據類型來聲明變量。

3. 使用JavaScript的腳本應用對象。通常這些對象與C程序中的結構和方法相對應。

4. 將JS引擎API函數調用和變量引用插入到程序中，包括初始化內置JS對象、創建并配置用戶自定義對象。

5. 大多數JS引擎調用返回一個值。如果該值是NULL，一般表示錯誤發生。如果非NULL，表示成功，返回值一般是指針，程序需要使用或留到將來使用。應用程序應檢查JS引擎調用的返回值。

要讓應用程序能解釋JavaScript，你必須遵循某些JS API嵌入習慣。下面的例子簡要說明需要嵌入到你的應用程序中去的一些API調用函數。大部分情況下，這些函數的插入順序是很重要的。例如，在調用其他JS API之前必須初始化JS RunTime，同樣在終止程序之前必須釋放JS RunTime。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* 包含JS引擎的API頭文件 */
#include "jsapi.h"
.
.
.
//主程序聲明全局JS變量，包括RunTime、一個Context和一個全局對象，然后初始化JS RunTime、創建一個Context。
int main(int argc, char **argv)
{
  int c, i;
  /*聲明全局JS變量，包括全局和自定義對象*/
  JSVersion version;
  JSRuntime *rt;
  JSContext *cx;
  JSObject  *glob, *it;
  JSBool builtins;
  /* 初始化JS RunTime，返回結果給rt */
  rt = JS_NewRuntime(8L * 1024L * 1024L);
  /* 如果rt為空，程序終止 */
  if (!rt)
    return 1;
  /* 創建一個Context，并將其與JS RunTime關聯起來 */
  cx = JS_NewContext(rt, 8192);
  /* 如果cx為空，程序終止 */
  if (cx == NULL)
    return 1;
  /* 創建全局對象 */
  glob = JS_NewObject(cx, clasp, NULL, NULL);
  /* 實例化內置對象和全局對象*/
  builtins = JS_InitStandardClasses(cx, glob);
  .
  .
  .
  return 0;
}

如上面這個例子所示，調用JS引擎的應用程序必須首先創建JS RunTime，而且在終止程序之前要釋放這個RunTime。在實例化RunTime后，即可創建自己的JS對象模型。對象模型決定了JS對象之間的關系，JS對象本質上是一種層次結構。缺省情況下，所有的JS對象都與全局對象相關聯，它們都是全局對象的后代。當初始化標準的JS類時，你自動地得到一個全局對象：

builtins = JS_InitStandardClasses(cx, glob);

這個全局對象創建了一些基本的、被其它對象所繼承的性質和方法。當你創建自定義對象時，它們自動使用全局對象所定義的性質和方法。你可以在自定義對象上重新定義這些性質和方法，從而重載這些缺省的性質和方法。當然，你也可以接受這些缺省的分配。 你可以在內置JS對象或其它自定義對象的基礎上創建自己的對象。無論哪種情況，你所創建的對象都繼承了層次鏈中父對象、一直上溯到全局對象的全部性質和方法。

回頁首

管理RunTime

JS RunTime是內存空間，JS引擎利用它來管理上下文、對象和與JS函數及腳本相關的變量。在執行JS函數或腳本之前，首先要調用JS_NewRunTime來初始化一個RunTime。JS_NewRunTime函數攜帶一個unsigned整型參數，這個參數指定了在碎片收集之前分配給RunTime內存的最大字節數。例如：

rt = JS_NewRuntime(8L * 1024L * 1024L);

如上所示，JS_NewRuntime返回一個指向RunTime的指針。非NULL表示創建成功。

正常情況下，一個程序只需一個RunTime。當然，根據需要創建多個RunTime并將它們保存在不同指針上也是可以的。

JS_DestroyRuntime(rt);

如果你創建了多個RunTime，務必在應用程序終止前將每個都銷毀。

回頁首

管理上下文(Contexts)

幾乎所有的JS API調用都要求你傳遞一個上下文參數。在JavaScript引擎中一個上下文代表一個腳本，引擎傳遞上下文信息給運行腳本的線程。每個同時運行的腳本必須指派一個唯一的上下文。當一個腳本運行完后，它的上下文也不再有用，因此這個上下文可以重新指派給一個新的腳本，或將其釋放。

調用函數JS_NewContext為某個腳本創建一個新的上下文。這個函數需要兩個參數：一個與該上下文相關的RunTime指針，分配給該上下文的棧空間字節數。如果調用成功，函數返回一個指針，它指向這個新建立的上下文。例如：

JSContext *cx;
      .
      .
      .
cx = JS_NewContext(rt, 8192);

這個RunTime必須已經存在。你指派給上下文的棧空間必須足夠大以便提供給使用該上下文的腳本所創建的變量和對象。注意，因為需要一些與分配和維護上下文相關的overhead，你必須做到：在應用程序中必須根據需要來確定創建上下文的數量；要確保上下文在被應用程序所需要時存在，而不是反復銷毀和需要時重新創建。

當某個上下文不再需要時，它應被銷毀、釋放內存資源給其它程序使用。根據應用程序中JS使用的范圍，可以在使用完后及時銷毀，或將其保留并反復利用直到應用程序終止。無論哪種情況，當上下文不再需要時都要調用函數JS_DestroyContext來釋放它，這個函數攜帶一個指針參數，它指向要被釋放的上下文：

JS_DestroyContext(cx);

如果你的應用程序創建了多個RunTime，那么，應用程序可能需要知道某個上下文是與哪個RunTime相關聯的。這種情況下，可以調用函數JS_GetRuntime，同時傳遞該上下文作為參數。JS_GetRuntime返回一個指針，它指向合適的RunTime（如果存在的話）：

rt=JS_GetRuntime(cx);

當你創建一個上下文，你要給它指派棧空間用于存放變量和對象。在一個給定的上下文中，你也能夠存放大量的數據。但是，你必須將所需的棧空間盡可能地降到最小。調用JS_SetContextPrivate函數創建一個指針，它指向該上下文所需的私有數據，調用JS_GetContextPrivate函數得到這個指針以便你能存取這數據。你的應用程序負責創建和管理私有數據。

要創建私有數據并將其與上下文相關聯：首先，創建私有數據，即常規的C語言void* 變量；然后，調用JS_SetContextPrivate函數，并指定創建私有數據的上下文和指向該數據的指針。例如：

JS_SetContextPrivate(cx,pdata);

隨后要獲取這個數據指針，請調用JS_GetContextPrivate，并傳遞這個上下文作為參數。這個函數返回指向私有數據的指針：

pdata=JS_GetContextPrivate(cx);

<?xml encoding="US-ASCII"?>
<!ELEMENT order (header,item+,price)>
<!ELEMENT header (billing,shipping)>
<!ELEMENT billing (name,address,creditCard)>
<!ELEMENT shipping (name,address)>
<!ELEMENT name EMPTY>

回頁首

對象的處理

1．創建內置對象和全局JS對象

JavaScript引擎提供若干個內置對象，使得你的開發任務得以簡化。例如，內置數組(Array)對象使得在JS引擎中創建和操作數組結構很容易。類似地，日期(Date)對象提供了一個操作日期的統一機制。要了解內置對象支持的全部內容，請參閱JS_InitStandardClasses。 JS引擎一直使用函數和全局對象。通常，全局對象居留在幕后，為應用程序中創建和使用的其它JS對象及全局變量提供缺省范圍。在創建自己的對象前，你必須初始化全局對象。函數對象使得對象具有和調用構造函數的功能。

一個簡單的API調用，JS_InitStandardClasses，初始化全局和函數對象、內置引擎對象，方便應用程序使用它們：

JSBool builtins;
      .
      .
      .
builtins = JS_InitStandardClasses(cx, glob);

JS_InitStandardClasses函數返回一個JS布爾值，表示初始化成功與否。

你也可以為應用程序指定另外一個不同的全局對象。例如，Navigator使用window作為其全局對象。要改變應用程序的全局對象，請調用JS_SetGlobalObject。要了解更多信息，請參閱JS_SetGlobalObject。

2．創建并初始化自定義對象

除了使用引擎內置對象外，你還可以創建、初始化并使用自己的JS對象。特別是你在使用JS引擎用腳本來自動化應用程序時更是如此。自定義的JS對象能提供直接的程序服務，或者作為你的程序服務的接口。

有兩種方法來創建JS引擎能使用的自定義對象：

1. 寫一個JS腳本，它創建一個對象、性質、方法、構造函數，然后將這個腳本傳遞給JS引擎。

2. 將代碼插入到你的應用程序中，它定義了對象的性質和方法，調用引擎來初始化一個新對象，然后通過額外的引擎調用設置對象的性質。這種方法的好處是，應用程序能包含操作對象的本地方法。

無論哪種情況，如果你創建一個對象，然后讓其存在于被其它腳本使用的RunTime中，你可以調用JS_AddRef和JS_AddNamedRoot使該對象為根。使用這些函數，確保JS引擎能跟蹤這些對象并在碎片收集時清除它們。

3．如何將自定義對象嵌入到應用程序中

將自定義對象插入到應用程序中是很有用的，比如，當對象持續需要時，或者你知道有多個腳本需要使用一個對象。將自定義對象插入到應用程序中的步驟是：

• 創建一個JSPropertySpec數據類型，將對象的屬性信息指派給它，包括屬性的GET和PUT方法名字。

• 創建一個JSFunctionSpec數據類型，將被你的對象所使用的方法信息指派給它。

• 創建實際的C函數，它們在響應你的對象方法調用時被執行。

• 調用JS_NewObject和JS_ConstructObject函數，以便實例化該對象。

• 調用JS_DefineFunctions函數來創建對象的方法。

• 調用JS_DefineProperties函數來創建對象的屬性。

描述持續的、自定義的JS對象的代碼必須放在靠近程序執行的開始部分，在那些依耐于先前已存在對象的代碼之前。

4．給對象提供私有數據

象上下文一樣，你可以將大量的數據與對象進行關聯，而不是將這些數據直接存放在對象里。調用JS_SetPrivate函數來創建指向對象私有數據的指針，調用JS_GetPrivate函數來獲取這個指針以便你能存取這些數據。你的應用程序負責創建和管理這些私有數據。

創建私有數據并將其與對象關聯的方法：

1）創建私有數據，作為C語言的void*變量。 2）調用JS_SetPrivate函數，指定對象和私有數據指針。

例如：

JS_SetContextPrivate(cx,obj,pdata);

隨后，要獲取這些數據，請調用JS_GetPrivate函數，將對象作為參數進行傳遞。這個函數返回指向對象私有數據的指針：

pdata=JS_GetContextPrivate(cx,obj);

回頁首

數據處理

1．處理JS數據類型

JavaScript定義了自己的數據類型。有些數據類型直接對應于C語言中的副本。其它的，如JSObject、jsdouble和JSString，都是JavaScript獨有的。

通常，你可以在應用程序中像使用標準的C語言數據類型一樣聲明、使用JS數據類型，JS引擎對那些需要多于一個字存儲空間的JS數據類型的變量保持單獨的棧，例如：JSObject、jsdouble和JSString。引擎會周期性地檢查這些變量，看看它們是否仍在使用，如果沒有，引擎就碎片收集它們，釋放存儲空間。

2．處理JS值

除了JS數據類型以外，JS引擎也使用JS值，稱其為jsvals。一個jsval本質上是一個指針，指向除了整型以外的JS數據類型。對于整型，一個jsval包含這個值自身。其它情況，指針被編碼成包含額外信息。利用jsvals提高引擎的效率，允許API函數處理大量的潛在數據類型。 引擎API包含一組宏，用于測試一個jsval的JS數據類型。他們是：

• JSVAL_IS_OBJECT

• JSVAL_IS_NUMBER

• JSVAL_IS_INT

• JSVAL_IS_DOUBLE

• JSVAL_IS_STRING

• JSVAL_IS_BOOLEAN

除了測試一個jsval的潛在數據類型外，也能測試它看是否是原始JS數據類型（JSVAL_IS_PRIMITIVE)。原始數據類型是undefined、null、boolean、numeric和string類型。

你也可測試jsval指向的值是否為NULL（JSVAL_IS_NULL）或void（JSVAL_IS_VOID）。

如果一個jsval指向一個JSObject、 jsdouble或 jsstr等JS數據類型，你可利用JSVAL_TO_OBJECT、 JSVAL_TO_DOUBLE、 JSVAL_TO_STRING將jsval轉為它的潛在類型。

3．處理JS字符串

你在JavaScript中做的許多事情都會涉及到字符串，JS引擎實現了一個稱為JSString的字符串數據類型和一個指向JS字符數組的指針類型即jschar，用類處理Unicode編碼的字符串。這個引擎也實現了一組通用的Unicode字符串程序。最后，JS引擎也提供內置串的支持，兩個或多個獨立的字符串在內存中能共享一個串。對于JSString類型的字符串，這個引擎跟蹤并管理串資源。

一般說來，當你用JS引擎操縱字符串時，你應該用JS API串處理函數來創建和復制字符串。有字符串管理程序用于創建NULL結尾的字符串或者指定長度的字符串。同時，也有程序用于計算字符串長度、比較字符串。

4．對Unicode和Interned字符串的支持

像其他API調用一樣，具有Unicode能力的API字符串函數的名字與標準的引擎API字符串函數的名字是一一對應的。例如，如果一個標準函數名為JS_NewStringCopyN，對應的Unicode版函數就是JS_NewUCStringCopN。具有Unicode處理能力的API字符串函數對于interned字符串也是可行的。

為了節約空間，JS引擎為共享單個字符串實例提供支持。這種共享的字符串稱為"interned strings"。當你事先知道程序中會創建一個特定的、文本字符串并且要多次使用它時，請利用interned字符串。

引擎為interned字符串提供了若干個調用：

• JS_InternString，用于創建或再次使用一個JSString。

• JS_InternUCString，用于創建或再次使用一個Unicode類型的JSString。

• JS_InternUCStringN，用于創建或再次使用固定長度的Unicode型JSString。

5．安全控制

對于JavaScript1.3，JS引擎增加了安全增強型API函數，用于編譯和運行傳遞給引擎的腳本或函數。JS安全模型是基于Java安全模型的。這個模型提供了一個通用的安全接口，但是，具體的安全實現是由應用程序自己來完成的。

安全機制用在能夠支持JavaScript的應用程序中的一種通用情形是比較腳本的真實性或者限制腳本的交互性。例如，你可以比較一個應用程序中兩個或多個腳本的代碼庫，只允許來自同一個代碼庫的腳本能夠修改共享代碼庫的腳本屬性。

如果要實現安全JS，請按以下步驟：

1）在程序中聲明一個或者多個JSPrincipals類型的結構。

2）實現將給數組提供安全信息的函數。這些函數包括：給你的應用程序提供一個principals數組，用一套給定的規則對JS對象的引用數進行加減操作的機制。

3）用你的安全信息給JSPrincipals結構賦值，這個信息可以包括通用代碼信息。

4）在運行時間環境中，編譯與執行全部腳本和函數。下面列出了這些API函數和它們的目的：

• JS_CompileScriptForPrincipals：編譯但不執行一段具有安全能力的腳本。

• JS_CompileUCScriptForPrincipals：編譯但不執行一段具有安全能力、Unicode編碼的腳本。

• JS_CompileFunctionForPrincipals：利用一個文本字符串創建一個具有安全能力的JS函數。

• JS_CompileUCFunctionForPrincipals：利用一個Unicode編碼的文本字符串創建一個具有安全信息的JS函數。

• JS_EvaluateScriptForPrincipals ：編譯并執行一段具有安全能力的腳本。

• JS_EvaluateUCScriptForPrincipals：編譯并執行一段具有安全能力、用Unicode編碼的腳本。

回頁首

程序樣例

以下是一個簡單的樣例程序，它從文件test.js中讀入一段腳本，然后解釋執行并輸出結果。腳本中可嵌入自定義對象People，People對象具有屬性name(表示該人的姓名)、address（表示該人的地址）及方法print（在屏幕上顯示該人的姓名、地址信息）。

例如：下面是一段簡單的js腳本，它首先利用print方法輸出該人的姓名和地址，然后將姓名和地址分別修改為John和Beijing，最后再次輸出其姓名和地址，看是否修改正確。

people.print();

people.name="John";

people.address="Beijing";

people.print();

下面是C源程序代碼。

#include "js.h"
enum tagMY_PEOPLE {MY_NAME,MY_ADDRESS};
static JSBool GetPeopleProperty (JSContext *cx, JSObject *obj, jsval id, jsval *vp);
static JSBool SetPeopleProperty (JSContext *cx, JSObject *obj, jsval id, jsval *vp);
static JSBool PeoplePrint(JSContext *cx, JSObject *obj, uintN argc, 
        jsval *argv, jsval *rval);
typedef struct{
    char name[16];
    char addr[64];}PeopleInfo;
static PeopleInfo m_ainfo={"myName","myAddress"};
/*定義屬性的 GETTER*/
static JSBool GetPeopleProperty (JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
    if (JSVAL_IS_INT(id)) {
        switch (JSVAL_TO_INT(id)) {
            case MY_NAME:
                *vp=STRING_TO_JSVAL (JS_NewStringCopyZ (cx,m_ainfo.name));
                break;
            case MY_ADDRESS:
                *vp=STRING_TO_JSVAL (JS_NewStringCopyZ (cx,m_ainfo.addr));
                break;
            }
    }
    return JS_TRUE;
}
/*定義屬性的SETTER*/
static JSBool SetPeopleProperty (JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
    if (JSVAL_IS_INT(id)) {
        switch (JSVAL_TO_INT(id)) {
            case MY_NAME:
                strncpy (m_ainfo.name, JS_GetStringBytes (jss), 15);
                break;
            case MY_ADDRESS:
                strncpy (m_ainfo.addr, JS_GetStringBytes (jss), 63);
                break;
            }
    }
    return JS_TRUE;
}
/*定義print方法*/
static JSBool PeoplePrint(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, 
   jsval *rval)
{
    fprintf(stdout,"My Name is %s.\nMy Addr is %s.\n",m_ainfo.name,m_ainfo.addr);
    return JS_TRUE;
}
void main()
{
    JSString* jss;
    char buf[5120];
    int len;
    jsval rval;
    JSRuntime *rt;
    JSContext *cx;
    JSObject *globalObj,*PeopleObj;
    JSClass global_class = {
            "global",0,
            JS_PropertyStub, JS_PropertyStub,JS_PropertyStub, JS_PropertyStub,
            JS_EnumerateStub, JS_ResolveStub,JS_ConvertStub, JS_FinalizeStub };
/*定義People類的屬性數組*/
static JSPropertySpec PeopleProperties[] =
  {
    {"name", MY_NAME,    JSPROP_ENUMERATE },
    {"address",  MY_ADDRESS,     JSPROP_ENUMERATE },
    {0}
  } ;
/*定義People類的方法數組*/
static JSFunctionSpec PeopleMethods[] =
{
    {"print",          PeoplePrint,     0},
             {0}
        };
/*定義People類*/
static JSClass PeopleClass = {
        "people",0,
  JS_PropertyStub,JS_PropertyStub, GetPeopleProperty, SetPeopleProperty,
  JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub
};
    typedef struct{}
      /* 初始化JS RunTime，返回結果給rt */
rt = JS_Init(1000000L);
    if (!rt)return;
  /* 創建一個上下文，并將其與JS RunTime關聯起來 */
    cx = JS_NewContext(rt, 5120);
    if (!cx)return;
  /* 創建全局對象 */
    if (!(globalObj = JS_NewObject (cx, &global_class, NULL, NULL)))return;
      /* 實例化內置對象和全局對象*/
JS_InitStandardClasses (cx, globalObj);
/*實例化People對象*/
PeopleObj = JS_DefineObject (cx, globalObj, "People", &PeopleClass, 0,JSPROP_ENUMERATE);
/*創建對象的屬性*/
JS_DefineProperties (cx,PeopleObj, PeopleProperties);
/*創建對象的方法*/
JS_DefineFunctions (cx,PeopleObj, PeopleMethods);
FILE* fp;
/*打開文件，讀入腳本*/
    if (!(fp = fopen ("test.js", "r")))return;
    len = fread (buf, 1, 5120, fp);
    fclose (fp);
    if (len <= 0)return;
/*執行一段腳本*/
    JS_EvaluateScript (cx, globalObj, buf, len, "", 1, &rval);
    jss = JS_ValueToString (cx, rval);
    fprintf(stdout，"The result is: %s"，JS_GetStringBytes (jss));
/*釋放上下文*/
JS_DestroyContext(cx);
/*釋放RunTime*/
JS_DestroyRuntime(rt);
return;
}

感謝各位的閱讀！關于“JavaScript引擎SpiderMonkey怎么用”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！