Редактирование: Qt:Документация 4.3.2/qtscript

{{Qt4.3.2_header}}

[Предыдущая: [[Qt:Документация 4.3.2/qtsvg | Модуль QtSvg]] ]  [ [[Qt:Документация 4.3.2/modules | Модули Qt]] ] [Следующая: [[Qt:Документация 4.3.2/qtxml | Модуль QtXml]] ] 

=Модуль QtScript<br />=
Модуль QtScript предоставляет классы для Qt scriptable приложений. [[#details | Далее...]]

==Классы==
{|  width="100%" class="annotated" cellpadding="2" cellspacing="1" border="0"
|- valign="top" class="odd" | 
![[Qt:Документация 4.3.2/qscriptcontext | QScriptContext]]
|Представляет функции Qt Script
|- valign="top" class="even" | 
![[Qt:Документация 4.3.2/qscriptengine | QScriptEngine]]
|Среда для оценки Qt Script кода
|- valign="top" class="odd" | 
![[Qt:Документация 4.3.2/qscriptextensionplugin | QScriptExtensionPlugin]]
|Абстрактный базовый для настройки расширенных плагинов QScript
|- valign="top" class="even" | 
![[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]]
|Действия как контейнеры для типов данных Qt Script
|- valign="top" class="odd" | 
![[Qt:Документация 4.3.2/qscriptvalueiterator | QScriptValueIterator]]
|Итератор Java-style для QScriptValue
|- valign="top" class="even" | 
![[Qt:Документация 4.3.2/qscriptable | QScriptable]]
|Доступ к Qt Script переменным средам из Qt C++ функций членов
|}
<div id="details"></div>
==Подробное описание==

*[[#configuring-the-build-process | Настройка процесса сборки]]
*[[#language-overview | Обзор языка]]
*[[#basic-usage | Базовое использование]]
*[[#making-a-qobject-available-to-the-script-engine | Доступность QObject в Script Engine]]
**[[#using-signals-and-slots | Использование сигналов и слотов]]
***[[#signal-to-function-connections | Signal to Function Connections]]
***[[#signal-to-member-function-connections | Signal to Member Function Connections]]
***[[#signal-to-named-member-function-connections | Signal to Named Member Function Connections]]
***[[#error-handling | Обработка ошибок]]
***[[#emitting-signals-from-scripts | Отправка сигналов из скриптов]]
***[[#overloaded-signals-and-slots | Перегруженные сигналы и слоты]]

**[[#accessing-properties | Свойства доступа]]
**[[#accessing-child-qobjects | Доступ к дочерним объектам]]
**[[#controlling-qobject-ownership | Controlling QObject Ownership]]
**[[#customizing-access-to-the-qobject | Настройка доступа к QObject]]

*[[#conversion-between-qtscript-and-c-types | Конвертация между QtScript и C++ типами]]
*[[#how-to-design-and-implement-application-objects | Как разрабатывать и применять объекты приложения]]
**[[#making-a-c-object-available-to-scripts-written-in-qt-script | Making a C++ object available to Scripts Written in Qt Script]]
**[[#making-c-class-member-functions-available-in-qt-script | Making C++ Class Member Functions Available in Qt Script]]
**[[#making-c-class-properties-available-in-qt-script | Making C++ Class Свойства Available in Qt Script]]
**[[#reacting-to-c-objects-signals-in-scripts | Reacting to C++ Objects Сигналы in Scripts]]
**[[#design-of-application-objects | Design of Application Objects]]

*[[#making-use-of-prototype-based-inheritance | Making Use of Prototype-Based Inheritance]]
**[[#prototype-objects-and-shared-properties | Prototype Objects and Shared Свойства]]
**[[#defining-classes-in-a-prototype-based-universe | Defining Classes in a Prototype-Based Universe]]
**[[#prototype-based-programming-with-the-qtscript-c-api | Prototype-Based Programming with the QtScript C++ API]]

*[[#ecmascript-compatibility | Совместимость ECMAScript]]
*[[#qt-script-extensions-to-ecmascript | Расширения Qt Script для ECMAScript]]
<div id="configuring-the-build-process"></div>
===Настройка процесса сборки===

Приложения которые используют классы Qt Script нужно сконфигурировать для сборки с модулем QtScript. Для включения определения модуля классов, используйте следующую директиву:
<source lang="cpp-qt"> #include <QtScript></source> 
Чтобы привязать модуль, добавьте эту строку в ваш [[Qt:Документация 4.3.2/qmake-manual#qmake | qmake]] <tt>.pro</tt> файл:
<source lang="cpp-qt"> QT += script</source> 
Модуль QtScript является частью [[Qt:Документация 4.3.2/commercialeditions#qt-desktop-edition | Qt Desktop Edition]] и [[Qt:Документация 4.3.2/opensourceedition | Qt Open Source Edition]].
<div id="language-overview"></div>
===Обзор языка===

Qt Script is based on the ECMAScript scripting language, as defined in standard [http://www.ecma-international.org/publications/standards/Ecma-262.htm ECMA-262]. Microsoft's JScript, and Netscape's JavaScript are also based on the ECMAScript standard. For an overview of ECMAScript, see the [[Qt:Документация 4.3.2/ecmascript | ECMAScript reference]]. If you are not familiar with the ECMAScript language, there are several existing tutorials and books that cover this subject, such as [http://www.davidflanagan.com/javascript5/ JavaScript: The Definitive Guide].
<div id="basic-usage"></div>
===Basic Usage===

To evaluate script code, you create a [[Qt:Документация 4.3.2/qscriptengine | QScriptEngine]] and call its evaluate() function, passing the script code (text) to evaluate as argument.
<source lang="cpp-qt">     QScriptEngine engine;
     qDebug() << "the magic number is:" << engine.evaluate("1 + 2").toNumber();</source> 
The return value will be the result of the evaluation (represented as a [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] object); this can be converted to standard C++ and Qt types.

Custom properties can be made available to scripts by registering them with the script engine. This is most easily done by setting properties of the script engine's '''Global Object''':
<source lang="cpp-qt">     QScriptValue val(&amp;engine, 123);
     engine.globalObject().setProperty("foo", val);
     qDebug() << "foo times two is:" << engine.evaluate("foo * 2").toNumber();</source> 
This places the properties in the script environment, thus making them available to script code.
<div id="making-a-qobject-available-to-the-script-engine"></div>
===Making a QObject Available to the Script Engine===

Any [[Qt:Документация 4.3.2/qobject | QObject]] subclass can be made available for use with scripts.

When a [[Qt:Документация 4.3.2/qobject | QObject]] is passed to the [[Qt:Документация 4.3.2/qscriptengine#newQObject | QScriptEngine::newQObject]]() function, a QtScript wrapper object is created that can be used to make the [[Qt:Документация 4.3.2/qobject | QObject]]'s signals, slots, properties, and child objects available to scripts. Because QtScript uses Qt's meta-object system, there is no need to implement any additional wrappers or bindings.

Here's an example of making an instance of a [[Qt:Документация 4.3.2/qobject | QObject]] subclass available to script code under the name <tt>"myObject"</tt>:
<source lang="cpp-qt">     QScriptEngine engine;
     QObject *someObject = new MyObject;
     QScriptValue objectValue = engine.newQObject(someObject);
     engine.globalObject().setProperty("myObject", objectValue);</source> 
The [[Qt:Документация 4.3.2/qscriptengine#newQObject | newQObject()]] function accepts two additional optional arguments: one is the ownership mode, and the other is a collection of options that allow you to control certain aspects of how the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] that wraps the [[Qt:Документация 4.3.2/qobject | QObject]] should behave. We will come back to the usage of these arguments later.
<div id="using-signals-and-slots"></div>
====Using Сигналы and Slots====

QtScript uses a different syntax for connecting to and disconnecting from signals than what you're familiar with from C++ (i.e&#x2e; [[Qt:Документация 4.3.2/qobject#connect | QObject::connect]]()). To connect to a signal, you reference the relevant signal as a property of the sender object, and invoke its <tt>connect()</tt> function. There are three overloads of <tt>connect()</tt>, each with a corresponding <tt>disconnect()</tt> overload. The following subsections describe these three forms.
<div id="signal-to-function-connections"></div>
=====Signal to Function Connections=====

<tt>connect(function)</tt>

In this form of connection, the argument to <tt>connect()</tt> is the function to connect to the signal.
<source lang="cpp-qt"> function myInterestingScriptFunction() { ... }
 ...
 myQObject.somethingChanged.connect(myInterestingScriptFunction);</source> 
The argument can be a QtScript function, as in the above example, or it can be a [[Qt:Документация 4.3.2/qobject | QObject]] slot, as in the following example:
<source lang="cpp-qt"> myQObject.somethingChanged.connect(myOtherQObject.doSomething);</source> 
When the argument is a [[Qt:Документация 4.3.2/qobject | QObject]] slot, the argument types of the signal and slot do not necessarily have to be compatible; QtScript will, if necessary, perform conversion of the signal arguments to match the argument types of the slot.

To disconnect from a signal, you invoke the signal's <tt>disconnect()</tt> function, passing the function to disconnect as argument:
<source lang="cpp-qt"> myQObject.somethingChanged.disconnect(myInterestingFunction);
 myQObject.somethingChanged.disconnect(myOtherQObject.doSomething);</source> 
When a script function is invoked in response to a signal, the `this' object will be the Global Object.
<div id="signal-to-member-function-connections"></div>
=====Signal to Member Function Connections=====

<tt>connect(thisObject, function)</tt>

In this form of the <tt>connect()</tt> function, the first argument is the object that will be bound to the variable, <tt>this</tt>, when the function specified using the second argument is invoked.

If you have a push button in a form, you typically want to do something involving the form in response to the button's <tt>clicked</tt> signal; passing the form as the <tt>this</tt> object makes sense in such a case.
<source lang="cpp-qt"> var obj = { x: 123 };
 var fun = function() { print(this.x); };
 myQObject.somethingChanged.connect(obj, fun);</source> 
To disconnect from the signal, pass the same arguments to <tt>disconnect()</tt>:
<source lang="cpp-qt"> myQObject.somethingChanged.disconnect(obj, fun);</source> <div id="signal-to-named-member-function-connections"></div>
=====Signal to Named Member Function Connections=====

<tt>connect(thisObject, functionName)</tt>

In this form of the <tt>connect()</tt> function, the first argument is the object that will be bound to the variable, <tt>this</tt>, when a function is invoked in response to the signal. The second argument specifies the name of a function that is connected to the signal, and this refers to a member function of the object passed as the first argument (<tt>thisObject</tt> in the above scheme).

Note that the function is resolved when the connection is made, not when the signal is emitted.
<source lang="cpp-qt"> var obj = { x: 123, fun: function() { print(this.x); } };
 myQObject.somethingChanged.connect(obj, "fun");</source> 
To disconnect from the signal, pass the same arguments to <tt>disconnect()</tt>:
<source lang="cpp-qt"> myQObject.somethingChanged.disconnect(obj, "fun");</source> <div id="error-handling"></div>
=====Error Handling=====

When <tt>connect()</tt> or <tt>disconnect()</tt> succeeds, the function will return <tt>undefined</tt>; otherwise, it will throw a script exception. You can obtain an error message from the resulting <tt>Error</tt> object. Example:
<source lang="cpp-qt"> try {
     myQObject.somethingChanged.connect(myQObject, "slotThatDoesntExist");
 } catch (e) {
     print(e);
 }</source> <div id="emitting-signals-from-scripts"></div>
=====Emitting Сигналы from Scripts=====

To emit a signal from script code, you simply invoke the signal function, passing the relevant arguments:
<source lang="cpp-qt"> myQObject.somethingChanged("hello");</source> <div id="overloaded-signals-and-slots"></div>
=====Overloaded Сигналы and Slots=====

When a signal or slot is overloaded, QtScript will attempt to pick the right overload based on the actual types of the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] arguments involved in the function invocation. For example, if your class has slots <tt>myOverloadedSlot(int)</tt> and <tt>myOverloadedSlot(QString)</tt>, the following script code will behave reasonably:
<source lang="cpp-qt"> myQObject.myOverloadedSlot(10);   // will call the int overload
 myQObject.myOverloadedSlot("10"); // will call the QString overload</source> 
You can specify a particular overload by using array-style property access with the [[Qt:Документация 4.3.2/qmetaobject#normalizedSignature | normalized signature]] of the C++ function as the property name:
<source lang="cpp-qt"> myQObject['myOverloadedSlot(int)']("10");   // call int overload; the argument is converted to an int
 myQObject['myOverloadedSlot(QString)'](10); // call QString overload; the argument is converted to a string</source> 
If the overloads have different number of arguments, QtScript will pick the overload with the argument count that best matches the actual number of arguments passed to the slot.

For overloaded signals, QtScript will connect to the most general overload, unless you refer to the signal with its full normalized signature.
<div id="accessing-properties"></div>
====Accessing Свойства====

The properties of the [[Qt:Документация 4.3.2/qobject | QObject]] are available as properties of the corresponding Qt Script object. When you manipulate a property in script code, the C++ get/set method for that property will automatically be invoked. For example, if your C++ class has a property declared as follows:
<source lang="cpp-qt"> Q_PROPERTY(bool enabled READ enabled WRITE setEnabled)</source> 
then script code can do things like the following:
<source lang="cpp-qt"> myQObject.enabled = true;

 ...

 myQObject.enabled = !myQObject.enabled;</source> <div id="accessing-child-qobjects"></div>
====Accessing Child QObjects====

Every named child of the [[Qt:Документация 4.3.2/qobject | QObject]] is by default available as a property of the corresponding Qt Script object. For example, if you have a [[Qt:Документация 4.3.2/qdialog | QDialog]] with a child widget whose <tt>objectName()</tt> is <tt>"okButton"</tt>, you can access this object in script code through the expression
<source lang="cpp-qt"> myDialog.okButton</source> 
Since <tt>objectName</tt> is itself a Q_PROPERTY, you can manipulate the name in script code to, for example, rename an object:
<source lang="cpp-qt"> myDialog.okButton.objectName = "cancelButton";
 // from now on, myDialog.cancelButton references the button</source> 
You can also use the functions <tt>findChild()</tt> and <tt>findChildren()</tt> to find children. These two functions behave identically to [[Qt:Документация 4.3.2/qobject#findChild | QObject::findChild]]() and [[Qt:Документация 4.3.2/qobject#findChildren | QObject::findChildren]](), respectively.

For example, we can use these functions to find objects using strings and regular expressions:
<source lang="cpp-qt"> var okButton = myDialog.findChild("okButton");
 if (okButton != null) {
    // do something with the OK button
 }

 var buttons = myDialog.findChildren(RegExp("button[0-9]+"));
 for (var i = 0; i < buttons.length; ++i) {
    // do something with buttons[i]
 }</source> 
You typically want to use <tt>findChild()</tt> when manipulating a form that uses nested layouts; that way the script is isolated from the details about which particular layout a widget is located in.
<div id="controlling-qobject-ownership"></div>
====Controlling QObject Ownership====

By default, the script engine does not take ownership of the [[Qt:Документация 4.3.2/qobject | QObject]] that is passed to [[Qt:Документация 4.3.2/qscriptengine#newQObject | QScriptEngine::newQObject]](); the object is managed according to Qt's object ownership (see [[Qt:Документация 4.3.2/objecttrees | Object Trees and Object Ownership]]). You can change this behavior by specifying a different ownership mode as the second argument, overriding the default ([[Qt:Документация 4.3.2/qscriptengine#ValueOwnership-enum | QScriptEngine::QtOwnership]]).

Specifying [[Qt:Документация 4.3.2/qscriptengine#ValueOwnership-enum | QScriptEngine::ScriptOwnership]] as the ownership mode will cause the script engine to take full ownership of the [[Qt:Документация 4.3.2/qobject | QObject]] and delete it when it determines that it is safe to do so. This ownership mode is appropriate if the [[Qt:Документация 4.3.2/qobject | QObject]] does not have a parent object, and/or the [[Qt:Документация 4.3.2/qobject | QObject]] is created in the context of the script engine and is not intended to outlive the script engine.

For example, a constructor function that constructs QObjects only to be used in the script environment is a good candidate:
<source lang="cpp-qt"> QScriptValue myQObjectConstructor(QScriptContext *context, QScriptEngine *engine)
 {
   // let the engine manage the new object's lifetime.
   return engine->newQObject(new MyQObject(), QScriptEngine::ScriptOwnership);
 }</source> 
Another ownership mode is [[Qt:Документация 4.3.2/qscriptengine#ValueOwnership-enum | QScriptEngine::AutoOwnership]], where the ownership is based on whether the [[Qt:Документация 4.3.2/qobject | QObject]] has a parent or not. If the QtScript garbage collector finds that the [[Qt:Документация 4.3.2/qobject | QObject]] is no longer referenced within the script environment, the [[Qt:Документация 4.3.2/qobject | QObject]] will be deleted '''only''' if it does not have a parent.
<div id="customizing-access-to-the-qobject"></div>
====Customizing Access to the QObject====

[[Qt:Документация 4.3.2/qscriptengine#newQObject | QScriptEngine::newQObject]]() can take a third argument which allows you to control various aspects of the access to the [[Qt:Документация 4.3.2/qobject | QObject]] through the QtScript wrapper object it returns.

[[Qt:Документация 4.3.2/qscriptengine#QObjectWrapOption-enum | QScriptEngine::ExcludeChildObjects]] specifies that child objects of the [[Qt:Документация 4.3.2/qobject | QObject]] should not appear as properties of the wrapper object.

[[Qt:Документация 4.3.2/qscriptengine#QObjectWrapOption-enum | QScriptEngine::ExcludeSuperClassСвойства]] and [[Qt:Документация 4.3.2/qscriptengine#QObjectWrapOption-enum | QScriptEngine::ExcludeSuperClassMethods]] can be used to avoid exposing members that are inherited from the [[Qt:Документация 4.3.2/qobject | QObject]]'s superclass. This is useful for defining a "pure" interface where inherited members don't make sense from a scripting perspective; e.g&#x2e;, you don't want script authors to be able to change the <tt>objectName</tt> property of the object or invoke the <tt>deleteLater()</tt> slot.

[[Qt:Документация 4.3.2/qscriptengine#QObjectWrapOption-enum | QScriptEngine::AutoCreateDynamicСвойства]] specifies that properties that don't already exist in the [[Qt:Документация 4.3.2/qobject | QObject]] should be created as dynamic properties of the [[Qt:Документация 4.3.2/qobject | QObject]], rather than as properties of the QtScript wrapper object. If you want new properties to truly become persistent properties of the [[Qt:Документация 4.3.2/qobject | QObject]], rather than properties that are destroyed along with the wrapper object (and that aren't shared if the [[Qt:Документация 4.3.2/qobject | QObject]] is wrapped multiple times with newQObject()), you should use this option.
<div id="conversion-between-qtscript-and-c-types"></div>
===Conversion Between QtScript and C++ Types===

QtScript will perform type conversion when a value needs to be converted from the script side to the C++ side or vice versa; for instance, when a C++ signal triggers a script function, when you access a [[Qt:Документация 4.3.2/qobject | QObject]] property in script code, or when you call [[Qt:Документация 4.3.2/qscriptengine#toScriptValue | QScriptEngine::toScriptValue]]() or [[Qt:Документация 4.3.2/qscriptengine#fromScriptValue | QScriptEngine::fromScriptValue]]() in C++. QtScript provides default conversion operations for many of the built-in Qt types. You can change the conversion operation for a type by registering your own conversion functions with [[Qt:Документация 4.3.2/qscriptengine#qScriptRegisterMetaType | qScriptRegisterMetaType]]().

The following table describes the default conversion from a [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] to a C++ type.


{|  width="100%" class="annotated" cellpadding="2" cellspacing="1" border="0"
|- valign="top" class="qt-style" | 
!C++ Type
!Default Conversion
|- valign="top" class="odd" | 
|bool
|[[Qt:Документация 4.3.2/qscriptvalue#toBoolean | QScriptValue::toBoolean]]()
|- valign="top" class="even" | 
|int
|[[Qt:Документация 4.3.2/qscriptvalue#toInt32 | QScriptValue::toInt32]]()
|- valign="top" class="odd" | 
|uint
|[[Qt:Документация 4.3.2/qscriptvalue#toUInt32 | QScriptValue::toUInt32]]()
|- valign="top" class="even" | 
|float
|float([[Qt:Документация 4.3.2/qscriptvalue#toNumber | QScriptValue::toNumber]]())
|- valign="top" class="odd" | 
|double
|[[Qt:Документация 4.3.2/qscriptvalue#toNumber | QScriptValue::toNumber]]()
|- valign="top" class="even" | 
|short
|short([[Qt:Документация 4.3.2/qscriptvalue#toInt32 | QScriptValue::toInt32]]())
|- valign="top" class="odd" | 
|ushort
|[[Qt:Документация 4.3.2/qscriptvalue#toUInt16 | QScriptValue::toUInt16]]()
|- valign="top" class="even" | 
|char
|char([[Qt:Документация 4.3.2/qscriptvalue#toInt32 | QScriptValue::toInt32]]())
|- valign="top" class="odd" | 
|uchar
|unsigned char([[Qt:Документация 4.3.2/qscriptvalue#toInt32 | QScriptValue::toInt32]]())
|- valign="top" class="even" | 
|qlonglong
|qlonglong([[Qt:Документация 4.3.2/qscriptvalue#toInteger | QScriptValue::toInteger]]())
|- valign="top" class="odd" | 
|qulonglong
|qulonglong([[Qt:Документация 4.3.2/qscriptvalue#toInteger | QScriptValue::toInteger]]())
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qstring | QString]]
|[[Qt:Документация 4.3.2/qscriptvalue#toString | QScriptValue::toString]]()
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qdatetime | QDateTime]]
|[[Qt:Документация 4.3.2/qscriptvalue#toDateTime | QScriptValue::toDateTime]]()
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qdate | QDate]]
|[[Qt:Документация 4.3.2/qscriptvalue#toDateTime | QScriptValue::toDateTime]]().date()
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qregexp | QRegExp]]
|[[Qt:Документация 4.3.2/qscriptvalue#toRegExp | QScriptValue::toRegExp]]()
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qobject | QObject]]*
|[[Qt:Документация 4.3.2/qscriptvalue#toQObject | QScriptValue::toQObject]]()
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qwidget | QWidget]]*
|[[Qt:Документация 4.3.2/qscriptvalue#toQObject | QScriptValue::toQObject]]()
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qvariant | QVariant]]
|[[Qt:Документация 4.3.2/qscriptvalue#toVariant | QScriptValue::toVariant]]()
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qchar | QChar]]
|If the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] is a string, the result is the first character of the string, or a null [[Qt:Документация 4.3.2/qchar | QChar]] if the string is empty; otherwise, the result is a [[Qt:Документация 4.3.2/qchar | QChar]] constructed from the unicode obtained by converting the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] to a <tt>ushort</tt>.
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qstringlist | QStringList]]
|If the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] is an array, the result is a [[Qt:Документация 4.3.2/qstringlist | QStringList]] constructed from the result of [[Qt:Документация 4.3.2/qscriptvalue#toString | QScriptValue::toString]]() for each array element; otherwise, the result is an empty [[Qt:Документация 4.3.2/qstringlist | QStringList]].
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qvariant#QVariantList-typedef | QVariantList]]
|If the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] is an array, the result is a [[Qt:Документация 4.3.2/qvariant#QVariantList-typedef | QVariantList]] constructed from the result of [[Qt:Документация 4.3.2/qscriptvalue#toVariant | QScriptValue::toVariant]]() for each array element; otherwise, the result is an empty [[Qt:Документация 4.3.2/qvariant#QVariantList-typedef | QVariantList]].
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qvariant#QVariantMap-typedef | QVariantMap]]
|If the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] is an object, the result is a [[Qt:Документация 4.3.2/qvariant#QVariantMap-typedef | QVariantMap]] with a (key, value) pair of the form (propertyName, propertyValue.toVariant()) for each property, using [[Qt:Документация 4.3.2/qscriptvalueiterator | QScriptValueIterator]] to iterate over the object's properties.
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qobject#QObjectList-typedef | QObjectList]]
|If the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] is an array, the result is a [[Qt:Документация 4.3.2/qobject#QObjectList-typedef | QObjectList]] constructed from the result of [[Qt:Документация 4.3.2/qscriptvalue#toQObject | QScriptValue::toQObject]]() for each array element; otherwise, the result is an empty [[Qt:Документация 4.3.2/qobject#QObjectList-typedef | QObjectList]].
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qlist | QList]]<int>
|If the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] is an array, the result is a [[Qt:Документация 4.3.2/qlist | QList]]<int> constructed from the result of [[Qt:Документация 4.3.2/qscriptvalue#toInt32 | QScriptValue::toInt32]]() for each array element; otherwise, the result is an empty [[Qt:Документация 4.3.2/qlist | QList]]<int>.
|}

Additionally, QtScript will handle the following cases:

*If the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] is a [[Qt:Документация 4.3.2/qobject | QObject]] and the target type name ends with <tt>*</tt> (i.e&#x2e;, it is a pointer), the [[Qt:Документация 4.3.2/qobject | QObject]] pointer will be cast to the target type with [[Qt:Документация 4.3.2/qobject#qobject_cast | qobject_cast]]().
*If the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] is a [[Qt:Документация 4.3.2/qvariant | QVariant]] and the target type name ends with <tt>*</tt> (i.e&#x2e;, it is a pointer), and the [[Qt:Документация 4.3.2/qvariant#userType | userType()]] of the [[Qt:Документация 4.3.2/qvariant | QVariant]] is the type that the target type points to, the result is a pointer to the [[Qt:Документация 4.3.2/qvariant | QVariant]]'s data.
*If the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] is a [[Qt:Документация 4.3.2/qvariant | QVariant]] and it can be converted to the target type (according to [[Qt:Документация 4.3.2/qvariant#canConvert | QVariant::canConvert]]()), the [[Qt:Документация 4.3.2/qvariant | QVariant]] will be cast to the target type with [[Qt:Документация 4.3.2/qvariant#qvariant_cast | qvariant_cast]]().

The following table describes the default behavior when a [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] is constructed from a C++ type:


{|  width="100%" class="annotated" cellpadding="2" cellspacing="1" border="0"
|- valign="top" class="qt-style" | 
!C++ Type
!Default Construction
|- valign="top" class="odd" | 
|void
|[[Qt:Документация 4.3.2/qscriptengine#undefinedValue | QScriptEngine::undefinedValue]]()
|- valign="top" class="even" | 
|bool
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, value)
|- valign="top" class="odd" | 
|int
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, value)
|- valign="top" class="even" | 
|uint
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, value)
|- valign="top" class="odd" | 
|float
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, value)
|- valign="top" class="even" | 
|double
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, value)
|- valign="top" class="odd" | 
|short
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, value)
|- valign="top" class="even" | 
|ushort
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, value)
|- valign="top" class="odd" | 
|char
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, value)
|- valign="top" class="even" | 
|uchar
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, value)
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qstring | QString]]
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, value)
|- valign="top" class="even" | 
|qlonglong
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, qsreal(value)). Note that the conversion may lead to loss of precision, since not all 64-bit integers can be represented using the qsreal type.
|- valign="top" class="odd" | 
|qulonglong
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](engine, qsreal(value)). Note that the conversion may lead to loss of precision, since not all 64-bit unsigned integers can be represented using the qsreal type.
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qchar | QChar]]
|[[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]](this, value.unicode())
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qdatetime | QDateTime]]
|[[Qt:Документация 4.3.2/qscriptengine#newDate | QScriptEngine::newDate]](value)
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qdate | QDate]]
|[[Qt:Документация 4.3.2/qscriptengine#newDate | QScriptEngine::newDate]](value)
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qregexp | QRegExp]]
|[[Qt:Документация 4.3.2/qscriptengine#newRegExp | QScriptEngine::newRegExp]](value)
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qobject | QObject]]*
|[[Qt:Документация 4.3.2/qscriptengine#newQObject | QScriptEngine::newQObject]](value)
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qwidget | QWidget]]*
|[[Qt:Документация 4.3.2/qscriptengine#newQObject | QScriptEngine::newQObject]](value)
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qvariant | QVariant]]
|[[Qt:Документация 4.3.2/qscriptengine#newVariant | QScriptEngine::newVariant]](value)
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qstringlist | QStringList]]
|A new script array (created with [[Qt:Документация 4.3.2/qscriptengine#newArray | QScriptEngine::newArray]]()), whose elements are created using the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]]([[Qt:Документация 4.3.2/qscriptengine | QScriptEngine]] *, [[Qt:Документация 4.3.2/qstring | QString]]) constructor for each element of the list.
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qvariant#QVariantList-typedef | QVariantList]]
|A new script array (created with [[Qt:Документация 4.3.2/qscriptengine#newArray | QScriptEngine::newArray]]()), whose elements are created using [[Qt:Документация 4.3.2/qscriptengine#newVariant | QScriptEngine::newVariant]]() for each element of the list.
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qvariant#QVariantMap-typedef | QVariantMap]]
|A new script object (created with [[Qt:Документация 4.3.2/qscriptengine#newObject | QScriptEngine::newObject]]()), whose properties are initialized according to the (key, value) pairs of the map.
|- valign="top" class="even" | 
|[[Qt:Документация 4.3.2/qobject#QObjectList-typedef | QObjectList]]
|A new script array (created with [[Qt:Документация 4.3.2/qscriptengine#newArray | QScriptEngine::newArray]]()), whose elements are created using [[Qt:Документация 4.3.2/qscriptengine#newQObject | QScriptEngine::newQObject]]() for each element of the list.
|- valign="top" class="odd" | 
|[[Qt:Документация 4.3.2/qlist | QList]]<int>
|A new script array (created with [[Qt:Документация 4.3.2/qscriptengine#newArray | QScriptEngine::newArray]]()), whose elements are created using the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]]([[Qt:Документация 4.3.2/qscriptengine | QScriptEngine]] *, int) constructor for each element of the list.
|}

Other types will be wrapped using [[Qt:Документация 4.3.2/qscriptengine#newVariant | QScriptEngine::newVariant]](). For null pointers of any type, the result is [[Qt:Документация 4.3.2/qscriptengine#nullValue | QScriptEngine::nullValue]]().
<div id="how-to-design-and-implement-application-objects"></div>
===How to Design and Implement Application Objects===

This section explains how to implement application objects and provides the necessary technical background material.
<div id="making-a-c-object-available-to-scripts-written-in-qt-script"></div>
====Making a C++ object available to Scripts Written in Qt Script====

Making C++ classes and objects available to a scripting language is not trivial because scripting languages tend to be more dynamic than C++, and it must be possible to introspect objects (query information such as function names, function signatures, properties, etc., at run-time). Standard C++ does not provide features for this.

We can achieve the functionality we want by extending C++, using C++'s own facilities so our code is still standard C++. The Qt meta-object system provides the necessary additional functionality. It allows us to write using an extended C++ syntax, but converts this into standard C++ using a small utility program called [[Qt:Документация 4.3.2/moc#moc | moc]] (Meta-Object Compiler). Classes that wish to take advantage of the meta-object facilities are either subclasses of [[Qt:Документация 4.3.2/qobject | QObject]], or use the <tt>Q_OBJECT</tt> macro. Qt has used this approach for many years and it has proven to be solid and reliable. Qt Script uses this meta-object technology to provide scripters with dynamic access to C++ classes and objects.

To completely understand how to make C++ objects available to Qt Script, some basic knowledge of the Qt meta-object system is very helpful. We recommend that you read the [[Qt:Документация 4.3.2/object | Qt Object Model]]. The information in this document and the documents it links to are very useful for understanding how to implement application objects.

However, this knowledge is not essential in the simplest cases. To make an object available in Qt Script, it must derive from [[Qt:Документация 4.3.2/qobject | QObject]]. All classes which derive from [[Qt:Документация 4.3.2/qobject | QObject]] can be introspected and can provide the information needed by the scripting engine at run-time; e.g&#x2e;, class name, functions, signatures. Because we obtain the information we need about classes dynamically at run-time, there is no need to write wrappers for [[Qt:Документация 4.3.2/qobject | QObject]] derived classes.
<div id="making-c-class-member-functions-available-in-qt-script"></div>
====Making C++ Class Member Functions Available in Qt Script====

The meta-object system also makes information about signals and slots dynamically available at run-time. By default, for [[Qt:Документация 4.3.2/qobject | QObject]] subclasses, only the signals and slots are automatically made available to scripts. This is very convenient because, in practice, we normally only want to make specially chosen functions available to scripters. When you create a [[Qt:Документация 4.3.2/qobject | QObject]] subclass, make sure that the functions you want to expose to Qt Script are public slots.

For example, the following class definition enables scripting only for certain functions:
<source lang="cpp-qt">   class MyObject : public QObject
   {
       Q_OBJECT

   public:
       MyObject( ... );

       void aNonScriptableFunction();

   public slots: // these functions (slots) will be available in Qt Script
       void calculate( ... );
       void setEnabled( bool enabled );
       bool isEnabled() const;

   private:
      ....

   };</source> 
In the example above, aNonScriptableFunction() is not declared as a slot, so it will not be available in Qt Script. The other three functions will automatically be made available in Qt Script because they are declared in the <tt>public slots</tt> section of the class definition.

It is possible to make any function script-invokable by specifying the <tt>Q_INVOKABLE</tt> modifier when declaring the function:
<source lang="cpp-qt"> class MyObject : public QObject
 {
     Q_OBJECT

     public:
     Q_INVOKABLE void thisMethodIsInvokableInQtScript();
     void thisMethodIsNotInvokableInQtScript();

     ...
 };</source> 
Once declared with <tt>Q_INVOKABLE</tt>, the method can be invoked from Qt Script code just as if it were a slot. Although such a method is not a slot, you can still specify it as the target function in a call to <tt>connect()</tt> in script code; <tt>connect()</tt> accepts both native and non-native functions as targets.
<div id="making-c-class-properties-available-in-qt-script"></div>
====Making C++ Class Свойства Available in Qt Script====

In the previous example, if we wanted to get or set a property using Qt Script we would have to write code like the following:
<source lang="cpp-qt">   var obj = new MyObject;
   obj.setEnabled( true );
   print( "obj is enabled: " + obj.isEnabled() );</source> 
Scripting languages often provide a property syntax to modify and retrieve properties (in our case the enabled state) of an object. Many script programmers would want to write the above code like this:
<source lang="cpp-qt">   var obj = new MyObject;
   obj.enabled = true;
   print( "obj is enabled: " + obj.enabled );</source> 
To make this possible, you must define properties in the C++ [[Qt:Документация 4.3.2/qobject | QObject]] subclass. For example, the following <tt>MyObject</tt> class declaration declares a boolean property called <tt>enabled</tt>, which uses the function <tt>setEnabled(bool)</tt> as its setter function and <tt>isEnabled()</tt> as its getter function:
<source lang="cpp-qt">   class MyObject : public QObject
   {
       Q_OBJECT
       // define the enabled property
       Q_PROPERTY( bool enabled WRITE setEnabled READ isEnabled )

   public:
       MyObject( ... );

       void aNonScriptableFunction();

   public slots: // these functions (slots) will be available in Qt Script
       void calculate( ... );
       void setEnabled( bool enabled );
       bool isEnabled() const;

   private:
      ....

   };</source> 
The only difference from the original code is the use of the macro <tt>Q_PROPERTY</tt>, which takes the type and name of the property, and the names of the setter and getter functions as arguments.

If you don't want a property of your class to be accessible in QtScript, you set the <tt>SCRIPTABLE</tt> attribute to <tt>false</tt> when declaring the property; by default, the <tt>SCRIPTABLE</tt> attribute is <tt>true</tt>. For example:
<source lang="cpp-qt"> Q_PROPERTY(int nonScriptableProperty READ foo WRITE bar SCRIPTABLE false)</source> <div id="reacting-to-c-objects-signals-in-scripts"></div>
====Reacting to C++ Objects Сигналы in Scripts====

In the Qt object model, signals are used as a notification mechanism between QObjects. This means one object can connect a signal to another object's slot and, every time the signal is emitted, the slot is called. This connection is established using the [[Qt:Документация 4.3.2/qobject#connect | QObject::connect]]() function.

The signals and slots mechanism is also available to Qt Script programmers. The code to declare a signal in C++ is the same, regardless of whether the signal will be connected to a slot in C++ or in Qt Script.
<source lang="cpp-qt">   class MyObject : public QObject
   {
       Q_OBJECT
       // define the enabled property
       Q_PROPERTY( bool enabled WRITE setEnabled READ isEnabled )

   public:
       MyObject( ... );

       void aNonScriptableFunction();

   public slots: // these functions (slots) will be available in Qt Script
       void calculate( ... );
       void setEnabled( bool enabled );
       bool isEnabled() const;

   signals: // the signals
       void enabledChanged( bool newState );

   private:
      ....

   };</source> 
The only change we have made to the code in the previous section is to declare a signals section with the relevant signal. Now, the script writer can define a function and connect to the object like this:
<source lang="cpp-qt">   function enabledChangedHandler( b )
   {
       print( "state changed to: " + b );
   }

   function init()
   {
       var obj = new MyObject();
       // connect a script function to the signal
       obj["enabledChanged(bool)"].connect(enabledChangedHandler);
       obj.enabled = true;
       print( "obj is enabled: " + obj.enabled );
   }</source> <div id="design-of-application-objects"></div>
====Design of Application Objects====

The previous section described how to implement C++ objects which can be used in Qt Script. Application objects are the same kind of objects, and they make your application's functionality available to Qt Script scripters. Since the C++ application is already written in Qt, many objects are already QObjects. The easiest approach would be to simply add all these QObjects as application objects to the scripting engine. For small applications this might be sufficient, but for larger applications this is probably not the right approach. The problem is that this method reveals too much of the internal API and gives script programmers access to application internals which should not be exposed.

Generally, the best way of making application functionality available to scripters is to code some QObjects which define the applications public API using signals, slots, and properties. This gives you complete control of the functionality made available by the application. The implementations of these objects simply call the functions in the application which do the real work. So, instead of making all your QObjects available to the scripting engine, just add the wrapper QObjects.
<div id="making-use-of-prototype-based-inheritance"></div>
===Making Use of Prototype-Based Inheritance===

In ECMAScript, inheritance is based on the concept of '''shared prototype objects'''; this is quite different from the class-based inheritance familiar to C++ programmers. With Qt Script, you can associate a custom prototype object with a C++ type using [[Qt:Документация 4.3.2/qscriptengine#setDefaultPrototype | QScriptEngine::setDefaultPrototype]](); this is the key to providing a script interface to that type. Since the QtScript module is built on top of Qt's meta-type system, this can be done for any C++ type. This section explains the underlying concepts of prototype-based inheritance. Once these concepts are understood, the associated practices can be applied throughout the QtScript API in order to create well-behaved, consistent bindings to C++ that will fit nicely into the ECMAScript universe.

When experimenting with QtScript objects and inheritance, it can be helpful to use the interactive interpreter included with the QtScript examples, located in <tt>examples/script/qscript</tt>.
<div id="prototype-objects-and-shared-properties"></div>
====Prototype Objects and Shared Свойства====

The purpose of a Qt Script '''prototype object''' is to define behavior that should be shared by a set of other QtScript objects. We say that objects which share the same prototype object belong to the same ''class'' (again, on the technical side this should not to be confused with the class constructs of languages like C++ and Java; ECMAScript has no such construct).

The basic prototype-based inheritance mechanism works as follows: Each QtScript object has an internal link to another object, its ''prototype''. When a property is looked up in an object, and the object itself does not have the property, the property is looked up in the prototype object instead; if the prototype has the property, then that property is returned. Otherwise, the property is looked up in the prototype of the prototype object, and so on; this chain of objects constitutes a '''prototype chain'''. The chain of prototype objects is followed until the property is found or the end of the chain is reached.

For example, when you create a new object by the expression <tt>new Object()</tt>, the resulting object will have as its prototype the standard <tt>Object</tt> prototype, <tt>Object.prototype</tt>; through this prototype relation, the new object inherits a set of properties, including the <tt>hasOwnProperty()</tt> function and <tt>toString()</tt> function:
<source lang="cpp-qt"> var o = new Object();
 o.foo = 123;
 print(o.hasOwnProperty('foo')); // true
 print(o.hasOwnProperty('bar')); // false
 print(o); // calls o.toString(), which returns "[object Object]"</source> 
The <tt>toString()</tt> function itself is not defined in <tt>o</tt> (since we did not assign anything to <tt>o.toString</tt>), so instead the <tt>toString()</tt> function in the standard <tt>Object</tt> prototype is called, which returns a highly generic string representation of <tt>o</tt> ("[object Object]").

Note that the properties of the prototype object are not ''copied'' to the new object; only a ''link'' from the new object to the prototype object is maintained. This means that changes done to the prototype object will immediately be reflected in the behavior of all objects that have the modified object as their prototype.
<div id="defining-classes-in-a-prototype-based-universe"></div>
====Defining Classes in a Prototype-Based Universe====

In Qt Script, a class is not defined explicitly; there is no <tt>class</tt> keyword. Instead, you define a new class in two steps:

#Define a '''constructor function''' that will initialize new objects.
#Set up a '''prototype object''' that defines the class interface, and assign this object to the public <tt>prototype</tt> property of the constructor function.

With this arrangement, the constructor's public <tt>prototype</tt> property will automatically be set as the prototype of objects created by applying the <tt>new</tt> operator to your constructor function; e.g&#x2e;, the prototype of an object created by <tt>new Foo()</tt> will be the value of <tt>Foo.prototype</tt>.

Functions that don't operate on the <tt>this</tt> object ("static" methods) are typically stored as properties of the constructor function, not as properties of the prototype object. The same is true for constants, such as enum values.

The following code defines a simple constructor function for a class called <tt>Person</tt>:
<source lang="cpp-qt"> function Person(name)
 {
   this.name = name;
 }</source> 
Next, you want to set up <tt>Person.prototype</tt> as your prototype object; i.e&#x2e;, define the interface that should be common to all <tt>Person</tt> objects. Qt Script automatically creates a default prototype object (by the expression <tt>new Object()</tt>) for every script function; you can add properties to this object, or you can assign your own custom object. (Generally speaking, any Qt Script object can act as prototype for any other object.)

Here's an example of how you might want to override the <tt>toString()</tt> function that <tt>Person.prototype</tt> inherits from <tt>Object.prototype</tt>, to give your <tt>Person</tt> objects a more appropriate string representation:
<source lang="cpp-qt"> Person.prototype.toString = function() { return "Person(name: " + this.name + ")"; }</source> 
This resembles the process of reimplementing a virtual function in C++. Henceforth, when the property named <tt>toString</tt> is looked up in a <tt>Person</tt> object, it will be resolved in <tt>Person.prototype</tt>, not in <tt>Object.prototype</tt> as before:
<source lang="cpp-qt"> var p1 = new Person("John Doe");
 var p2 = new Person("G.I. Jane");
 print(p1); // "Person(name: John Doe)"
 print(p2); // "Person(name: G.I. Jane)"</source> 
There are also some other interesting things we can learn about a <tt>Person</tt> object:
<source lang="cpp-qt"> print(p1.hasOwnProperty('name')); // 'name' is an instance variable, so this returns true
 print(p1.hasOwnProperty('toString')); // returns false; inherited from prototype
 print(p1 instanceof Person); // true
 print(p1 instanceof Object); // true</source> 
The <tt>hasOwnProperty()</tt> function is not inherited from <tt>Person.prototype</tt>, but rather from <tt>Object.prototype</tt>, which is the prototype of <tt>Person.prototype</tt> itself; i.e&#x2e;, the prototype chain of <tt>Person</tt> objects is <tt>Person.prototype</tt> followed by <tt>Object.prototype</tt>. This prototype chain establishes a ''class hierarchy'', as demonstrated by applying the <tt>instanceof</tt> operator; <tt>instanceof</tt> checks if the value of the public <tt>prototype</tt> property of the constructor function on the right-hand side is reached by following the prototype chain of the object on the left-hand side.

When defining subclasses, there's a general pattern you can use. The following example shows how one can create a subclass of <tt>Person</tt> called <tt>Employee</tt>:
<source lang="cpp-qt"> function Employee(name, salary)
 {
   Person.call(this, name); // call base constructor

   this.salary = salary;
 }

 // set the prototype to be an instance of the base class
 Employee.prototype = new Person();

 // initialize prototype
 Employee.prototype.toString = function() { ... }</source> 
Again, you can use the <tt>instanceof</tt> to verify that the class relationship between <tt>Employee</tt> and <tt>Person</tt> has been correctly established:
<source lang="cpp-qt"> var e = new Employee("Johnny Bravo", 5000000);
 print(e instanceof Employee); // true
 print(e instanceof Person);   // true
 print(e instanceof Object);   // true
 print(e instanceof Array);    // false</source> 
This shows that the prototype chain of <tt>Employee</tt> objects is the same as that of <tt>Person</tt> objects, but with <tt>Employee.prototype</tt> added to the front of the chain.
<div id="prototype-based-programming-with-the-qtscript-c-api"></div>
====Prototype-Based Programming with the QtScript C++ API====

You can use [[Qt:Документация 4.3.2/qscriptengine#newFunction | QScriptEngine::newFunction]]() to wrap native functions. When implementing a constructor function, you also pass the prototype object as an argument to [[Qt:Документация 4.3.2/qscriptengine#newFunction | QScriptEngine::newFunction]](). You can call [[Qt:Документация 4.3.2/qscriptvalue#construct | QScriptValue::construct]]() to call a constructor function, and you can use [[Qt:Документация 4.3.2/qscriptvalue#call | QScriptValue::call]]() from within a native constructor function if you need to call a base class constructor.

The [[Qt:Документация 4.3.2/qscriptable | QScriptable]] class provides a convenient way to implement a prototype object in terms of C++ slots and properties. Take a look at the [[Qt:Документация 4.3.2/script-defaultprototypes | Default Prototypes Example]] to see how this is done. Alternatively, the prototype functionality can be implemented in terms of standalone native functions that you wrap with [[Qt:Документация 4.3.2/qscriptengine#newFunction | QScriptEngine::newFunction]]() and set as properties of your prototype object by calling [[Qt:Документация 4.3.2/qscriptvalue#setProperty | QScriptValue::setProperty]]().

In the implementation of your prototype functions, you use [[Qt:Документация 4.3.2/qscriptable#thisObject | QScriptable::thisObject]]() (or [[Qt:Документация 4.3.2/qscriptcontext#thisObject | QScriptContext::thisObject]]()) to obtain a reference to the [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]] being operated upon; then you call [[Qt:Документация 4.3.2/qscriptvalue#qscriptvalue_cast | qscriptvalue_cast]]() to cast it to your C++ type, and perform the relevant operations using the usual C++ API for the type.

You associate a prototype object with a C++ type by calling [[Qt:Документация 4.3.2/qscriptengine#setDefaultPrototype | QScriptEngine::setDefaultPrototype]](). Once this mapping is established, Qt Script will automatically assign the correct prototype when a value of such a type is wrapped in a [[Qt:Документация 4.3.2/qscriptvalue | QScriptValue]]; either when you explicitly call [[Qt:Документация 4.3.2/qscriptengine#toScriptValue | QScriptEngine::toScriptValue]](), or when a value of such a type is returned from a C++ slot and internally passed back to script code by the engine. This means you ''don't'' have to implement wrapper classes if you use this approach.
<div id="ecmascript-compatibility"></div>
===ECMAScript Compatibility===

Qt Script implements all the built-in classes and functions defined in ECMA-262.

The Date parsing and string conversion functions are implemented using [[Qt:Документация 4.3.2/qdatetime#fromString | QDateTime::fromString]]() and [[Qt:Документация 4.3.2/qdatetime#toString | QDateTime::toString]](), respectively.

The RegExp class is a wrapper around [[Qt:Документация 4.3.2/qregexp | QRegExp]]. The [[Qt:Документация 4.3.2/qregexp | QRegExp]] semantics do not precisely match the semantics for regular expressions defined in ECMA-262.
<div id="qt-script-extensions-to-ecmascript"></div>
===Qt Script Extensions to ECMAScript===

*<tt>__proto__</tt> <br /> The prototype of an object ([[Qt:Документация 4.3.2/qscriptvalue#prototype | QScriptValue::prototype]]()) can be accessed through its <tt>__proto__</tt> property in script code. This property has the [[Qt:Документация 4.3.2/qscriptvalue#PropertyFlag-enum | QScriptValue::Undeletable]] flag set. For example:<source lang="cpp-qt">   var o = new Object();   (o.__proto__ === Object.prototype); // this evaluates to true</source> 
*<tt>Object.prototype.__defineGetter__</tt> <br /> This function installs a getter function for a property of an object. The first argument is the property name, and the second is the function to call to get the value of that property. When the function is invoked, the <tt>this</tt> object will be the object whose property is accessed. For example:<source lang="cpp-qt">   var o = new Object();   o.__defineGetter__("x", function() { return 123; });   var y = o.x; // 123</source> 
*<tt>Object.prototype.__defineSetter__</tt> <br /> This function installs a setter function for a property of an object. The first argument is the property name, and the second is the function to call to set the value of that property. When the function is invoked, the <tt>this</tt> object will be the object whose property is accessed. For example:<source lang="cpp-qt">   var o = new Object();   o.__defineSetter__("x", function(v) { print("and the value is:", v); });   o.x = 123; // will print "and the value is: 123"</source> 
*<tt>Function.prototype.connect</tt> <br /> This function connects a signal to a slot. Usage of this function is described in the section [[#using-signals-and-slots | Using Сигналы and Slots]].
*<tt>Function.prototype.disconnect</tt> <br /> This function disconnects a signal from a slot. Usage of this function is described in the section [[#using-signals-and-slots | Using Сигналы and Slots]].
*<tt>QObject.prototype.findChild</tt> <br /> This function is semantically equivalent to [[Qt:Документация 4.3.2/qobject#findChild | QObject::findChild]]().
*<tt>QObject.prototype.findChildren</tt> <br /> This function is semantically equivalent to [[Qt:Документация 4.3.2/qobject#findChildren | QObject::findChildren]]().
*<tt>QObject.prototype.toString</tt> <br /> This function returns a default string representation of a [[Qt:Документация 4.3.2/qobject | QObject]].
*<tt>gc</tt> <br /> This function invokes the garbage collector.
*<tt>Error.prototype.backtrace</tt> <br /> This function returns a human-readable backtrace, in the form of an array of strings.
*Error objects have the following additional properties:
**<tt>lineNumber</tt>: The line number where the error occurred.
**<tt>fileName</tt>: The file name where the error occurred (if a file name was passed to [[Qt:Документация 4.3.2/qscriptengine#evaluate | QScriptEngine::evaluate]]()).
**<tt>stack</tt>: An array of objects describing the stack. Each object has the following properties:
***<tt>functionName</tt>: The function name, if available.
***<tt>fileName</tt>: The file name, if available.
***<tt>lineNumber</tt>: The line number, if available.

[Предыдущая: [[Qt:Документация 4.3.2/qtsvg | Модуль QtSvg]] ]  [ [[Qt:Документация 4.3.2/modules | Модули Qt]] ] [Следующая: [[Qt:Документация 4.3.2/qtxml | Модуль QtXml]] ] 

{{Qt4.3.2_footer}}