QScriptEngine Class Reference

[QtScript module]

该代码QScriptEngine类提供​​用于评估的Qt Script代码的环境。More…

继承QObject。

Types

• enum QObjectWrapOption { ExcludeChildObjects, ExcludeSuperClassMethods, ExcludeSuperClassProperties, AutoCreateDynamicProperties, ..., ExcludeSlots }
• class **[QObjectWrapOptions]($docs-index.htm)**
• enum ValueOwnership { QtOwnership, ScriptOwnership, AutoOwnership }

Methods

• __init__ (self)
• __init__ (self, QObject parent)
• abortEvaluation (self, QScriptValue result = QScriptValue())
• QScriptEngineAgent agent (self)
• QStringList availableExtensions (self)
• bool canEvaluate (self, QString program)
• clearExceptions (self)
• collectGarbage (self)
• QScriptContext currentContext (self)
• QScriptValue defaultPrototype (self, int metaTypeId)
• QScriptValue evaluate (self, QString program, QString fileName = QString(), int lineNumber = 1)
• QScriptValue globalObject (self)
• bool hasUncaughtException (self)
• QStringList importedExtensions (self)
• QScriptValue importExtension (self, QString extension)
• installTranslatorFunctions (self, QScriptValue object = QScriptValue())
• bool isEvaluating (self)
• QScriptValue newArray (self, int length = 0)
• QScriptValue newDate (self, float value)
• QScriptValue newDate (self, QDateTime value)
• QScriptValue newFunction (self, callable signature, int length = 0)
• QScriptValue newFunction (self, callable signature, QScriptValue prototype, int length = 0)
• QScriptValue newObject (self)
• QScriptValue newObject (self, QScriptClass scriptClass, QScriptValue data = QScriptValue())
• QScriptValue newQMetaObject (self, QMetaObject metaObject, QScriptValue ctor = QScriptValue())
• QScriptValue newQObject (self, QObject object, ValueOwnership ownership = QScriptEngine.QtOwnership, QObjectWrapOptions options = 0)
• QScriptValue newQObject (self, QScriptValue scriptObject, QObject qtObject, ValueOwnership ownership = QScriptEngine.QtOwnership, QObjectWrapOptions options = 0)
• QScriptValue newRegExp (self, QRegExp regexp)
• QScriptValue newRegExp (self, QString pattern, QString flags)
• QScriptValue newVariant (self, QVariant value)
• QScriptValue newVariant (self, QScriptValue object, QVariant value)
• QScriptValue nullValue (self)
• popContext (self)
• int processEventsInterval (self)
• QScriptContext pushContext (self)
• reportAdditionalMemoryCost (self, int size)
• setAgent (self, QScriptEngineAgent agent)
• setDefaultPrototype (self, int metaTypeId, QScriptValue prototype)
• setGlobalObject (self, QScriptValue object)
• setProcessEventsInterval (self, int interval)
• QScriptValue toObject (self, QScriptValue value)
• QScriptString toStringHandle (self, QString str)
• QScriptValue uncaughtException (self)
• QStringList uncaughtExceptionBacktrace (self)
• int uncaughtExceptionLineNumber (self)
• QScriptValue undefinedValue (self)

Static Methods

• QScriptSyntaxCheckResult checkSyntax (QString program)

Qt Signals

• void signalHandlerException (const QScriptValue&)

Detailed Description

该代码QScriptEngine类提供​​用于评估的Qt Script代码的环境。

请参阅QtScript文档，了解关于Qt的脚本语言，以及如何开始使用脚本你的C + +应用程序的信息。

Evaluating Scripts

使用evaluate（ ）来评估的脚本代码，这是C + +的等效内置的脚本功能eval()。

 QScriptEngine myEngine;
 [QScriptValue]($docs-qscriptvalue.html) three = myEngine.evaluate("1 + 2");

evaluate（ ）返回一个QScriptValue保存了评价的结果。该QScriptValue类提供函数计算结果转换为不同的C + +类型（如QScriptValue.toString（）和QScriptValue.toNumber（））。

下面的代码片段显示了一个脚本函数可以被定义，然后从C + +调用的使用QScriptValue.call（）：

 [QScriptValue]($docs-qscriptvalue.html) fun = myEngine.evaluate("(function(a, b) { return a + b; })");
 QScriptValueList args;
 args << 1 << 2;
 [QScriptValue]($docs-qscriptvalue.html) threeAgain = fun.call([QScriptValue]($docs-qscriptvalue.html)(), args);

如可以从上面的代码段中可以看出，一个脚本被提供给发动机以字符串的形式。加载脚本的一种常见方法是通过读取一个文件的内容，并把它传递给evaluate（）：

 [QString](qstring.html) fileName = "helloworld.qs";
 [QFile](qfile.html) scriptFile(fileName);
 if (!scriptFile.open([QIODevice](qiodevice.html).ReadOnly))
     // handle error
 [QTextStream](qtextstream.html) stream(&scriptFile);
 [QString](qstring.html) contents = stream.readAll();
 scriptFile.close();
 myEngine.evaluate(contents, fileName);

在这里，我们传递的文件名作为第二个参数evaluate（ ） 。这并不影响评价以任何方式，第二个参数是用来识别脚本调试通用字符串（例如，文件名我们现在将任何显示uncaughtExceptionBacktrace（ ）涉及脚本） 。

Engine Configuration

该globalObject（ ）函数返回Global Object与脚本引擎相关联。全局对象的属性是从任何脚本代码访问（也就是说，它们是全局变量） 。通常情况下，评估“用户”脚本之前，你会希望通过添加一个或多个属性的全局对象来配置脚本引擎：

 myEngine.globalObject().setProperty("myNumber", 123);
 ...
 [QScriptValue]($docs-qscriptvalue.html) myNumberPlusOne = myEngine.evaluate("myNumber + 1");

添加自定义属性的脚本环境是提供脚本API是特定于应用程序的标准方法之一。通常这些自定义属性是由创建的对象newQObject（）或newObject通过创建（ ）函数或构造函数newFunction（ ） 。

Script Exceptions

evaluate（ ）可以抛出一个脚本异常（例如，由于语法错误） ，在这种情况下，返回值是被抛出的值（通常是Error对象） 。您可以检查是否评估通过调用出现异常hasUncaughtException（ ） 。在这种情况下，你可以调用的错误对象的toString （）来获取错误消息。目前未捕获的异常，也可通过uncaughtException（ ） 。调用clearExceptions（ ）将导致任何未捕获的异常被清除。

 [QScriptValue]($docs-qscriptvalue.html) result = myEngine.evaluate(...);
 if (myEngine.hasUncaughtException()) {
     int line = myEngine.uncaughtExceptionLineNumber();
     qDebug() << "uncaught exception at line" << line << ":" << result.toString();
 }

该checkSyntax（）函数可以被用来确定是否代码可以被有效地传递给evaluate（ ） 。

Script Object Creation

使用newObject（）来创建一个标准的Qt Script对象，这是C + +的等效脚本语句new Object()。您可以使用对象特定功能​​的QScriptValue操纵脚本对象（例如QScriptValue.setProperty（））。同样地，使用newArray（）来创建一个Qt脚本数组对象。使用newDate（ ）来创建一个Date对象，并newRegExp（ ）来创建一个RegExp对象。

QObject Integration

使用newQObject（ ）来包装QObject（或子类）的指针。newQObject（ ）返回一个代理脚本对象，属性，孩子，的信号和槽QObject可作为代理对象的属性。不需要任何绑定代码，因为它是使用Qt元对象系统动态地进行。

 [QPushButton](qpushbutton.html) button;
 [QScriptValue]($docs-qscriptvalue.html) scriptButton = myEngine.newQObject(&button);
 myEngine.globalObject().setProperty("button", scriptButton);
 myEngine.evaluate("button.checkable = true");
 qDebug() << scriptButton.property("checkable").toBoolean();
 scriptButton.property("show").call(); // call the show() slot

使用qScriptConnect（ ）到一个C + +的信号连接到一个脚本函数，这是Qt脚本相当于QObject.connect（ ） 。当一个脚本函数以响应一个C + +的信号调用时，它可能会导致脚本异常，你可以连接到signalHandlerException（）信号捕捉这样的异常。

使用newQMetaObject（ ）来包装QMetaObject，这给你的一个“脚本表示”QObject基类。newQMetaObject（ ）返回一个代理脚本对象，可作为代理对象的属性的类的枚举值。您还可以指定将用于构造类的对象（例如，当构造函数是从一个脚本调用）的函数。对于具有“标准”的Qt类的构造函数， Qt的脚本可以提供一个默认的构造函数的脚本为你见scriptValueFromQMetaObject（ ） 。

如需了解更多信息QObject整合，见Making Applications Scriptable

Support for Custom C++ Types

使用newVariant（ ）来包装QVariant。这可以被用来存储自定义的值（非QObject已登记的Qt的间位型系统）的C + +类型。为了使这种类型的脚本化的，通常一个原型（代表）对象的C + +类通过调用相关联setDefaultPrototype（）;原型对象定义了C + +类型的脚本API 。不同的是QObject集成，没有自动绑定可能在这里，即你必须使用创建脚本API自己，例如QScriptable类。

使用fromScriptValue（ ）投从QScriptValue另一种类型，并toScriptValue（ ）来创建一个QScriptValue从另一个值。您可以指定C + +类型的转换是要与执行qScriptRegisterMetaType（）和qScriptRegisterSequenceMetaType（ ） 。默认情况下， Qt的脚本将使用QVariant存储自定义类型的值。

Importing Extensions

使用importExtension（ ）来导入基于插件的扩展进入发动机。通话availableExtensions（）来获取一个列表命名所有可用的扩展，importedExtensions（）来获取一个列表的命名只有那些已导入扩展。

Call pushContext（）打开了一个新的变量范围，popContext（ ）来关闭当前作用域。如果你正在实施，评估含临时变量定义（如脚本代码的扩展，这是非常有用var foo = 123;）是安全的丢弃时，评估已经完成。

Native Functions

使用newFunction（ ）包装机（C + + ）的功能，包括构造为自己的自定义类型，使得这些可以从脚本代码被调用。这些功能必须有签名QScriptEngine.FunctionSignature。然后，您可以通过该函数作为参数传递给newFunction（ ） 。这里是一个函数返回它的前两个参数的和的一个例子：

 [QScriptValue]($docs-qscriptvalue.html) myAdd([QScriptContext]($docs-qscriptcontext.html) *context, QScriptEngine *engine)
 {
    [QScriptValue]($docs-qscriptvalue.html) a = context->argument(0);
    [QScriptValue]($docs-qscriptvalue.html) b = context->argument(1);
    return a.toNumber() + b.toNumber();
 }

为了揭露这个功能的脚本代码，可以将其设置为全局对象的一个属性：

 [QScriptValue]($docs-qscriptvalue.html) fun = myEngine.newFunction(myAdd);
 myEngine.globalObject().setProperty("myAdd", fun);

一旦做到这一点，脚本代码可以调用你的函数在完全相同的方式作为一个“正常”的脚本函数：

 [QScriptValue]($docs-qscriptvalue.html) result = myEngine.evaluate("myAdd(myNumber, 1)");

Long-running Scripts

如果您需要评估从主（图形用户界面）线程可能长时间运行脚本，你应该首先调用setProcessEventsInterval（ ） ，以确保该GUI保持响应。你可以通过调用中止当前运行脚本abortEvaluation（ ） 。您可以决定是否发动机是通过调用当前正在运行的脚本isEvaluating（ ） 。

Garbage Collection

Qt的脚本对象可以被垃圾收集时，他们不再被引用。有没有保证，以时自动垃圾回收将会发生。

该collectGarbage（ ）函数可以被调用来显式地请求垃圾收集。

该reportAdditionalMemoryCost（ ）函数可以被调用，以表明一个Qt Script对象佔并非由脚本环境管理内存。报告的额外成本使得它更可能是垃圾收集器将被触发。这可能是有用的，例如，当许多习俗，当地人的Qt Script对象被分配。

Core Debugging/Tracing Facilities

由于Qt的4.4 ，您可以通过有关脚本执行（如脚本函数调用和语句的执行）活动通知QScriptEngineAgent接口，见setAgent（）函数。这可以被用来实现调试和代码QScriptEngine的分析。

Type Documentation

QScriptEngine.QObjectWrapOption

这些标志包装时指定一个选项QObject终场前newQObject（ ） 。

该QObjectWrapOptions类型是一个typedef为QFlags\u003cQObjectWrapOption\u003e 。它存储QObjectWrapOption值的或组合。

QScriptEngine.ValueOwnership

包装一个C + +的值，例如，当此枚举指定所有权通过使用newQObject（ ） 。

Method Documentation

QScriptEngine.__init__ (self)

构造一个QScriptEngine对象。

该globalObject（ ）初始化为具有属性中所描述 ECMA-262，第15.1节。

QScriptEngine.__init__ (self, QObject parent)

该parent的说法，如果不是没有，原因self通过Qt的，而不是PyQt的拥有。

构造一个QScriptEngine与给定对象parent。

该globalObject（ ）初始化为具有属性中所描述 ECMA-262，第15.1节。

QScriptEngine.abortEvaluation (self, QScriptValue result = QScriptValue())

中止任何脚本评估目前正在进行这款发动机。给定result被传递回作为评价的结果（即，它是从调用返回到evaluate（ ）被中止） 。

如果发动机没有评估一个脚本（即isEvaluating（ ）返回False ） ，这个函数不执行任何操作。

调用此函数，如果您需要中止正在运行的脚本出于某种原因，如当你发现这个脚本已经运行了几秒钟没有完成。

此功能被引入Qt的4.4 。

See also evaluate（ ）isEvaluating（）和setProcessEventsInterval（ ） 。

QScriptEngineAgent QScriptEngine.agent (self)

[

返回在此引擎上，或0当前已安装，如果没有安装代理的代理。

此功能被引入Qt的4.4 。

]($docs-qscriptengineagent.html)

See also setAgent（ ） 。

QStringList QScriptEngine.availableExtensions (self)

返回一个列表的命名可以导入现有的扩展使用importExtension（）函数。该列表包括已导入扩展。

此功能被引入Qt的4.4 。

See also importExtension（）和importedExtensions（ ） 。

bool QScriptEngine.canEvaluate (self, QString program)

QScriptSyntaxCheckResult QScriptEngine.checkSyntax (QString program)

检查给定的语法program。返回QScriptSyntaxCheckResult对象，该对象包含检查的结果。

此功能被引入Qt的4.5 。

QScriptEngine.clearExceptions (self)

清除在这款发动机的任何未捕获的异常。

此功能被引入Qt的4.4 。

See also hasUncaughtException（ ） 。

QScriptEngine.collectGarbage (self)

运行垃圾回收器。

垃圾收集器将尝试通过定位和处理不再可达脚本环境中的对象回收内存。

通常你不需要调用此函数;垃圾收集器会自动被调用时，QScriptEngine决定是明智的，这样做（即已经建立了一定数量的新对象时） 。但是，您可以明确地请求垃圾收集，应尽快进行调用这个函数。

See also reportAdditionalMemoryCost（ ） 。

QScriptContext QScriptEngine.currentContext (self)

[

返回当前上下文。

]($docs-qscriptcontext.html)

当前上下文通常访问来检索本地函数的参数和’ this’对象，为了方便，它可作为第一个参数QScriptEngine.FunctionSignature。

QScriptValue QScriptEngine.defaultPrototype (self, int metaTypeId)

返回与给定关联的默认原型metaTypeId，或无效QScriptValue如果没有预设的样机已定。

See also setDefaultPrototype（ ） 。

QScriptValue QScriptEngine.evaluate (self, QString program, QString fileName = QString(), int lineNumber = 1)

[

Evaluates program，使用lineNumber作为基准线数，并返回该评价的结果。

脚本代码会在当前上下文中进行评估。

]($docs-qscriptvalue.html)

的评价program可能会导致发动机异常，在这种情况下，返回值将是被抛出（通常是一个例外Error对象） 。您可以致电hasUncaughtException（ ） ，以确定是否发生在最后一次通话异常，评估（ ） 。

lineNumber用于指定一个开始行号为program;报告，涉及到本次评测的发动机（如行号信息uncaughtExceptionLineNumber（ ） ）将基于这个论点。例如，如果program由两行代码，并在第二行的语句会导致一个脚本异常，uncaughtExceptionLineNumber（ ）将返回给定的lineNumber加1 。当没有指定起始行号，行号为1型。

fileName用于错误报告。例如，在错误的对象的文件名可以访问通过“文件名”属性，如果它提供了这个功能。

See also canEvaluate（ ）hasUncaughtException（ ）isEvaluating（）和abortEvaluation（ ） 。

QScriptValue QScriptEngine.globalObject (self)

[

返回此引擎的全局对象。

]($docs-qscriptvalue.html)

默认情况下，全局对象包含了内置对象是一部分 ECMA-262，如数学，日期和字符串。此外，您可以设置全局对象的属性，以使所有脚本代码你自己的扩展。在脚本代码的非局部变量将被创建为全局对象的属性，以及在全局代码中的局部变量。

See also setGlobalObject（ ） 。

bool QScriptEngine.hasUncaughtException (self)

返回True如果最后一个脚本评价，导致未捕获的异常，否则返回False 。

唯一的例外状态被清除时，evaluate（）被调用。

See also uncaughtException（）和uncaughtExceptionLineNumber（ ） 。

QStringList QScriptEngine.importedExtensions (self)

返回一个列表的命名已导入的扩展使用importExtension（）函数。

此功能被引入Qt的4.4 。

See also availableExtensions（ ） 。

QScriptValue QScriptEngine.importExtension (self, QString extension)

进口给定的extension这个QScriptEngine。回报undefinedValue（ ）如果分机已成功导入。您可以致电hasUncaughtException（）来检查是否发生错误，在这种情况下，返回值是被抛出的异常（通常是一个值Error对象） 。

QScriptEngine确保一个特定的扩展仅导入一次，随后调用importExtension （ ）使用相同的扩展名会做什么，回报undefinedValue（ ） 。

See also availableExtensions（ ）QScriptExtensionPlugin和Creating QtScript Extensions。

QScriptEngine.installTranslatorFunctions (self, QScriptValue object = QScriptValue())

安装在给定的翻译功能object或全局对象上，如果没有指定对象。

Qt的剧本翻译的功能和C + +翻译功能之间的关系如下表所述：

此功能被引入Qt的4.5 。

See also Internationalization with Qt。

bool QScriptEngine.isEvaluating (self)

返回True如果该发动机目前正在评估一个脚本，否则返回False 。

此功能被引入Qt的4.4 。

See also evaluate（）和abortEvaluation（ ） 。

QScriptValue QScriptEngine.newArray (self, int length = 0)

创建QtScript与给定的类数组对象length。

See also newObject（ ） 。

QScriptValue QScriptEngine.newDate (self, float value)

创建QtScript之类的日期与给定对象value（毫秒自1970年1月1日的数字， UTC ） 。

QScriptValue QScriptEngine.newDate (self, QDateTime value)

创建QtScript从给定的类Date对象value。

See also QScriptValue.toDateTime（ ） 。

QScriptValue QScriptEngine.newFunction (self, callable signature, int length = 0)

创建QScriptValue一个封装了原生（ C + +）的功能。fun必须是一个C + +函数签名QScriptEngine.FunctionSignature。length是参数的数量fun预计，这将成为length的创建属性QScriptValue。

需要注意的是length只给出了函数需要的参数个数的指示，一个函数的实际调用可以包括任意数量的参数。您可以检查argumentCount()的QScriptContext与调用相关联，以确定传递的参数的实际数目。

A prototype属性是生成的函数对象自动创建的，以提供该功能将被用作构造函数的可能性。

通过结合newFunction （ ）和属性标志QScriptValue.PropertyGetter和QScriptValue.PropertySetter，您可以创建像在脚本代码的正常性能的脚本对象的属性，但实际上通过函数（类似于物业的工作访问Qt’s Property System） 。例如：

 static [QScriptValue]($docs-qscriptvalue.html) getSetFoo([QScriptContext]($docs-qscriptcontext.html) *context, [QScriptEngine]($docs-qscriptengine.html) *engine)
 {
     [QScriptValue]($docs-qscriptvalue.html) callee = context->callee();
     if (context->argumentCount() == 1) // writing?
         callee.setProperty("value", context->argument(0));
     return callee.property("value");
 }
 ....
 [QScriptValue]($docs-qscriptvalue.html) object = engine.newObject();
 object.setProperty("foo", engine.newFunction(getSetFoo),
     [QScriptValue]($docs-qscriptvalue.html).PropertyGetter | [QScriptValue]($docs-qscriptvalue.html).PropertySetter);

当属性foo脚本对象的脚本代码随后访问，getSetFoo()将被调用来处理访问。在这种特殊情况下，我们选择了存储的“真实”的价值foo作为访问函数本身的属性，你可以自由的做任何你喜欢这个功能。

在上面的例子中，一个单一的原生函数用来处理读取和写入属性;参数计数来确定，如果我们正在处理一个读或写。您还可以使用两个单独的函数，只需指定相关标志（QScriptValue.PropertyGetter or QScriptValue.PropertySetter）设置属性时，例如：

 [QScriptValue]($docs-qscriptvalue.html) object = engine.newObject();
 object.setProperty("foo", engine.newFunction(getFoo), [QScriptValue]($docs-qscriptvalue.html).PropertyGetter);
 object.setProperty("foo", engine.newFunction(setFoo), [QScriptValue]($docs-qscriptvalue.html).PropertySetter);

See also QScriptValue.call（ ） 。

QScriptValue QScriptEngine.newFunction (self, callable signature, QScriptValue prototype, int length = 0)

[

从创建一个构造函数fun用给定的length。该prototype所得到的函数的属性被设定为给定的prototype。该constructor物业prototype被设定为所产生的功能。

]($docs-qscriptvalue.html)

当一个函数被调用的构造函数（例如new Foo()） ，与函数调用相关的this'对象是新对象，该函数将初始化;这个默认构造对象的原型将是功能的公共prototype属性。如果你总是想要的功能表现为一个构造函数（如Foo()还应该创建一个新的对象） ，或者如果你需要创建自己的对象，而不是使用默认的 this’对象，你应该确保你的对象的原型是否设置正确，或者通过手动设置它，或者，当包装一个自定义类型，由经注册的defaultPrototype该类型的（） 。例如：

 [QScriptValue]($docs-qscriptvalue.html) Foo([QScriptContext]($docs-qscriptcontext.html) *context, [QScriptEngine]($docs-qscriptengine.html) *engine)
 {
     if (context->calledAsConstructor()) {
         // initialize the new object
         context->thisObject().setProperty("bar", ...);
         // ...
         // return a non-object value to indicate that the
         // thisObject() should be the result of the "new Foo()" expression
         return engine->undefinedValue();
     } else {
         // not called as "new Foo()", just "Foo()"
         // create our own object and return that one
         [QScriptValue]($docs-qscriptvalue.html) object = engine->newObject();
         object.setPrototype(context->callee().property("prototype"));
         object.setProperty("baz", ...);
         return object;
     }
 }
 ...
 [QScriptValue]($docs-qscriptvalue.html) fooProto = engine->newObject();
 fooProto.setProperty("whatever", ...);
 engine->globalObject().setProperty("Foo", engine->newFunction(Foo, fooProto));

包装一个自定义类型，并为它提供一个构造函数，你通常会做这样的事情：

 class Bar { ... };
 Q_DECLARE_METATYPE(Bar)
 [QScriptValue]($docs-qscriptvalue.html) constructBar([QScriptContext]($docs-qscriptcontext.html) *context, [QScriptEngine]($docs-qscriptengine.html) *engine)
 {
     Bar bar;
     // initialize from arguments in context, if desired
     ...
     return engine->toScriptValue(bar);
 }
 class BarPrototype : public [QObject]($docs-qobject.html), public [QScriptable]($docs-index.htm)
 {
 // provide the scriptable interface of this type using slots and properties
 ...
 };
 ...
 // create and register the Bar prototype and constructor in the engine
 BarPrototype *barPrototypeObject = new BarPrototype(...);
 [QScriptValue]($docs-qscriptvalue.html) barProto = engine->newQObject(barPrototypeObject);
 engine->setDefaultPrototype(qMetaTypeId<Bar>, barProto);
 [QScriptValue]($docs-qscriptvalue.html) barCtor = engine->newFunction(constructBar, barProto);
 engine->globalObject().setProperty("Bar", barCtor);

QScriptValue QScriptEngine.newObject (self)

创建QtScriptObject类的对象。

所创建的对象的原型将是对象的原型对象。

See also newArray（）和QScriptValue.setProperty（ ） 。

QScriptValue QScriptEngine.newObject (self, QScriptClass scriptClass, QScriptValue data = QScriptValue())

[

这是一个重载函数。

]($docs-qscriptvalue.html)

创建QtScript给定的类的对象，scriptClass。

所创建的对象的原型将是对象的原型对象。

data如果指定，则设定为新的对象的内部数据（使用QScriptValue.setData（））。

此功能被引入Qt的4.4 。

See also QScriptValue.scriptClass（）和reportAdditionalMemoryCost（ ） 。

QScriptValue QScriptEngine.newQMetaObject (self, QMetaObject metaObject, QScriptValue ctor = QScriptValue())

创建QtScript对象，它代表一个QObject类，使用给定的metaObject和构造函数ctor。

的枚举metaObject（与QENUMS申报）可作为创建的属性QScriptValue。当类被称为一个函数，_ctor将被调用来创建类的新实例。

例如：

 [QScriptValue]($docs-qscriptvalue.html) mySpecialQObjectConstructor([QScriptContext]($docs-qscriptcontext.html) *context,
                                          [QScriptEngine]($docs-qscriptengine.html) *engine)
 {
     [QObject]($docs-qobject.html) *parent = context->argument(0).toQObject();
     [QObject]($docs-qobject.html) *object = new [QObject]($docs-qobject.html)(parent);
     return engine->newQObject(object, [QScriptEngine]($docs-qscriptengine.html).ScriptOwnership);
 }
 ...
 [QScriptValue]($docs-qscriptvalue.html) ctor = engine.newFunction(mySpecialQObjectConstructor);
 [QScriptValue]($docs-qscriptvalue.html) metaObject = engine.newQMetaObject(&[QObject]($docs-qobject.html).staticMetaObject, ctor);
 engine.globalObject().setProperty("QObject", metaObject);
 [QScriptValue]($docs-qscriptvalue.html) result = engine.evaluate("new QObject()");

See also newQObject（）和scriptValueFromQMetaObject（ ） 。

QScriptValue QScriptEngine.newQObject (self, QObject object, ValueOwnership ownership = QScriptEngine.QtOwnership, QObjectWrapOptions options = 0)

创建QtScript对象，它封装了给定的QObject object，使用给定的ownership。给定options控制与所得到的脚本对象的交互的各个方面。

信号和槽，属性和儿童object可作为所创建的属性QScriptValue。欲了解更多信息，请参阅QtScript文档。

If object是一个空指针，这个函数返回nullValue（ ） 。

如果默认样机已经注册了object的类（或它的超类，递归） ，新的脚本对象的原型将被设置为默认的原型。

如果给定的object外面被删除QtScript的控制，任何试图访问已删除QObject的成员通过QtScript包装对象（通过脚本代码或C + + ）将导致脚本异常。

See also QScriptValue.toQObject（）和reportAdditionalMemoryCost（ ） 。

QScriptValue QScriptEngine.newQObject (self, QScriptValue scriptObject, QObject qtObject, ValueOwnership ownership = QScriptEngine.QtOwnership, QObjectWrapOptions options = 0)

[

这是一个重载函数。

初始化给定的scriptObject保持在给定qtObject，并返回该scriptObject。

]($docs-qscriptvalue.html)

此功能使您能够“促进”一个普通的Qt Script对象（由创建newObject（）函数），以一QObject代理，或取代QObject包含先前所创建的对象内newQObject（）函数。

的原型（ ）scriptObject将保持不变。

If scriptObject不是一个对象，这个函数的行为类似于正常newQObject（ ） ，也就是说，它会创建一个新的脚本对象并返回它。

当你想提供一个脚本构造的这个功能是非常有用的QObject基类。如果你的构造函数中调用一个new表达式（QScriptContext.isCalledAsConstructor（ ）返回True ） ，你可以通过QScriptContext.thisObject（ ） （默认构造脚本对象）这个函数来初始化新的对象。

此功能被引入Qt的4.4 。

See also reportAdditionalMemoryCost（ ） 。

QScriptValue QScriptEngine.newRegExp (self, QRegExp regexp)

创建QtScript一流的RegExp与给定的对象regexp。

See also QScriptValue.toRegExp（ ） 。

QScriptValue QScriptEngine.newRegExp (self, QString pattern, QString flags)

创建QtScript一流的RegExp与给定的对象pattern和flags。

法律标志是“G” （全局） ， ‘I’ （忽略大小写） ，和“M”（多行） 。

QScriptValue QScriptEngine.newVariant (self, QVariant value)

创建QtScript物体保持给定的变体value。

如果默认样机已经注册的元类型的idvalue，那么创建的对象的原型将是原型，否则，原型将是对象的原型对象。

See also setDefaultPrototype（ ）QScriptValue.toVariant（）和reportAdditionalMemoryCost（ ） 。

QScriptValue QScriptEngine.newVariant (self, QScriptValue object, QVariant value)

[

这是一个重载函数。

初始化给定的Qt脚本object以保持给定的变体value，并返回该object。

]($docs-qscriptvalue.html)

此功能使您能够“促进”一个普通的Qt Script对象（由创建newObject（）函数），以一个变体，或替换包含在对象内的变体通过先前建立的newVariant（）函数。

的原型（ ）object将保持不变。

If object不是一个对象，这个函数的行为类似于正常newVariant（ ） ，也就是说，它会创建一个新的脚本对象并返回它。

当你想提供一个脚本构造一个C + +类型，此功能非常有用。如果你的构造函数中调用一个new表达式（QScriptContext.isCalledAsConstructor（ ）返回True ） ，你可以通过QScriptContext.thisObject（ ） （默认构造脚本对象）这个函数来初始化新的对象。

此功能被引入Qt的4.4 。

See also reportAdditionalMemoryCost（ ） 。

QScriptValue QScriptEngine.nullValue (self)

返回QScriptValue的原始类型空。

See also undefinedValue（ ） 。

QScriptEngine.popContext (self)

跳出当前执行上下文，并恢复前一个。该功能必须在配合使用pushContext（ ） 。

See also pushContext（ ） 。

int QScriptEngine.processEventsInterval (self)

返回呼叫之间的时间间隔以毫秒为单位QCoreApplication.processEvents（ ）解释器运行时。

See also setProcessEventsInterval（ ） 。

QScriptContext QScriptEngine.pushContext (self)

进入一个新的执行上下文，并返回相关的QScriptContext对象。

一旦你与上下文做的，你应该叫popContext（ ）来恢复旧的上下文。

默认情况下，新的上下文的` this’对象是全局对象。上下文的callee（ ）将是无效的。

当您要评估的脚本代码，就好像它是一个函数体，此功能非常有用。您可以使用上下文的activationObject（ ）来初始化局部变量将提供给脚本。例如：

 [QScriptEngine]($docs-qscriptengine.html) engine;
 [QScriptContext]($docs-qscriptcontext.html) *context = engine.pushContext();
 context->activationObject().setProperty("myArg", 123);
 engine.evaluate("var tmp = myArg + 42");
 ...
 engine.popContext();

在上面的例子中，新的变量“TMP ”，在脚本中定义的将是本地上下文;换句话说，脚本不会对地球环境有任何影响。

万一栈溢出，则返回0

See also popContext（ ） 。

QScriptEngine.reportAdditionalMemoryCost (self, int size)

报告的给予额外的内存消耗size，以字节为单位，对垃圾收集器。

这个函数可以调用，以表明一个Qt Script对象都有一个与之关联的内存不是由Qt的脚本本身的管理。报告的额外成本使得它更可能是垃圾收集器将被触发。

请注意，如果额外的记忆体与脚本环境之外的对象共享，成本不应该被报导，因为收集了Qt Script对象将不会导致内存被释放反正。

Negative size值将被忽略，即这个功能不能用于报告，额外的内存已经被释放。

This function was introduced in Qt 4.7.

See also collectGarbage（ ） 。

QScriptEngine.setAgent (self, QScriptEngineAgent agent)

安装给定的agent在此引擎上。该代理将收到有关脚本执行的各种活动。当你想找出到底是什么引擎这样做是有用的，例如：何时evaluate（）被调用。代理接口是一样的调试器和分析器工具的基础。

该引擎维护的所有权agent。

如有调用此函数将取代现有的代理。

此功能被引入Qt的4.4 。

See also agent（ ） 。

QScriptEngine.setDefaultPrototype (self, int metaTypeId, QScriptValue prototype)

设置确定了在给定的C + +类的默认原型metaTypeId至prototype。

默认的原型为类型的值的脚本接口metaTypeId当该类型的值从脚本代码访问。每当脚本引擎（隐式或显式地）创建一个QScriptValue从类型的值metaTypeId，默认的原型将被设置为QScriptValue的原型。

该prototype对象本身可以使用的两个主要技术之一来建造;最简单的是子类化QScriptable，它使您能够通过定义类型的脚本APIQObject属性和插槽。另一种可能性是通过调用来创建一个脚本对象newObject（ ） ，并填充包裹所需的属性（如原生函数的对象newFunction（））。

See also defaultPrototype（ ）qScriptRegisterMetaType（ ）QScriptable和Default Prototypes Example。

QScriptEngine.setGlobalObject (self, QScriptValue object)

设置要在给定的这台发动机的全局对象object。如果object是不是一个有效的脚本对象，这个函数不执行任何操作。

当设置一个自定义的全局对象，你可能要使用QScriptValueIterator复制的标准全局对象的属性，或者，你可以设置你的自定义对象的内部原型是原始全局对象。

此功能被引入Qt的4.5 。

See also globalObject（ ） 。

QScriptEngine.setProcessEventsInterval (self, int interval)

设置呼叫QCoreApplication.processEvents之间的时间间隔interval毫秒。

当解释器运行时，所有事件处理是在默认情况下阻止。这意味着，例如，该GUI将不被更新和定时器将不被触发。以允许解释器在执行期间的事件处理1可指定的处理的时间间隔是一个正的值，表示毫秒的每个时间间隔的秒数QCoreApplication.processEvents（）被调用。

默认值是-1，这解释器执行过程中禁用事件处理。

您可以使用QCoreApplication.postEvent（）发表，在接下来的时间间隔进行自定义处理事件。例如，你可以保持的脚本和呼叫的总运行时间轨迹abortEvaluation当你发现这个脚本已经运行了很长一段时间没有完成（ ） 。

See also processEventsInterval（ ） 。

QScriptValue QScriptEngine.toObject (self, QScriptValue value)

转换给定的value一个对象，如果有这样的转换是可能的，否则返回一个无效的QScriptValue。该转换是根据下面的表执行：

此功能被引入Qt的4.5 。

See also newObject（ ） 。

QScriptString QScriptEngine.toStringHandle (self, QString str)

[

返回表示给定字符串的句柄，str。

]($docs-qscriptstring.html)

QScriptString可以用来快速查找属性和比较属性名的脚本对象。

此功能被引入Qt的4.4 。

See also QScriptValue.property（ ） 。

QScriptValue QScriptEngine.uncaughtException (self)

返回当前未捕获的异常，或无效QScriptValue如果没有捕获的异常。

唯一的例外值通常是一个Error对象，在这种情况下，你可以调用toString（）的返回值来获得一个错误消息。

See also hasUncaughtException（）和uncaughtExceptionLineNumber（ ） 。

QStringList QScriptEngine.uncaughtExceptionBacktrace (self)

返回最后一个未捕获的异常的人类可读的回溯。

它的形式为<function-name>()@<file-name>:<line-number>。

See also uncaughtException（ ） 。

int QScriptEngine.uncaughtExceptionLineNumber (self)

返回最近发生的未捕获异常的代码行数。

行号从1开始的，除非一个不同的基地被指定为第二个参数evaluate（ ） 。

See also hasUncaughtException（ ） 。

QScriptValue QScriptEngine.undefinedValue (self)

返回QScriptValue基本类型未定义的。

See also nullValue（ ） 。

Qt Signal Documentation

void signalHandlerException (const QScriptValue&)

这是该信号的默认超载。

当连接到一个信号的脚本功能使这个信号被发射的exception。

此功能被引入Qt的4.4 。

See also qScriptConnect（ ） 。