Operators - Revision history

Wormbo: some clarifications here and there

2011-03-05T10:04:11Z

some clarifications here and there

Wormbo: /* Operator precedence */

2011-03-04T13:56:25Z

‎Operator precedence

Wormbo: /* New operator */ object name is a string in UE3 as well

2010-05-28T21:16:05Z

‎New operator: object name is a string in UE3 as well

Wormbo: /* Special operators */

2010-04-15T11:51:10Z

‎Special operators

Wormbo: /* Operator precedence and associativity */ separated precedence and associativity sections, added more asociativity examples

2010-03-04T19:09:29Z

‎Operator precedence and associativity: separated precedence and associativity sections, added more asociativity examples

Wormbo: /* New operator */ mentioned Created() and sife effects of recreating an existing object

2010-01-11T10:46:27Z

‎New operator: mentioned Created() and sife effects of recreating an existing object

Wormbo: created actual article

2010-01-10T14:50:40Z

created actual article

Show changes

68.204.56.137: This is a start, taken from the official reference. It just needs formatting and an introduction.

2010-01-05T20:34:05Z

This is a start, taken from the official reference. It just needs formatting and an introduction.

New page

{{expand}}

$ (dollar sign)

string $ ( coerce string A, coerce string B )

Takes two strings and concatenates them.

Example: log("Unreal"$"Script"); //prints "UnrealScript"

$=

string $= ( out string A, coerce string B )

Concat two strings and assign it to the first.

Example: MyString $= "add this"; // does the same as: MyString = MyString$"add this"

@ (at)

string @ ( coerce string A, coerce string B )

Takes two strings and concatenates them with a space in-between.

Example: log("a"@"lot"); //prints "a lot"

@=

string @= ( out string A, coerce string B )

Analog to $= this operator will concat and assign (but with a space between the two strings).

Example: MyString @= "concat and assign with a space";

< (less-than)

bool < ( string A, string B )

Takes two strings and returns true if the first string is alphabetically before the second string. Note that capital letters are always alphabetically before lower case letters; consider Caps if case does not matter.

Example: ("Monkey" < "Robot") //this is TRUE.

> (greater-than)

bool > ( string A, string B )

Takes two strings and returns true if the first string is alphabetically after the second string. Note that capital letters are always alphabetically before lower case letters; consider Caps if case does not matter.

Example: ("Batman" > "Aquaman") //this is TRUE.

<= (less-than-or-equal-to)

bool <= ( string A, string B )

Takes two strings and returns true if the first string is alphabetically before or the same as the second string. Note that capital letters are always alphabetically before lower case letters; consider Caps if case does not matter.

Example:

("Monkey" <= "Robot") //this is TRUE.
("Monkey" <= "Monkey") //this is TRUE.

>= (greater-than-or-equal-to)

bool >= ( string A, string B )

Takes two strings and returns true if the first string is alphabetically after or the same as the second string. Note that capital letters are always alphabetically before lower case letters; consider Caps if case does not matter.

Example:

("Monkey" >= "Robot") //this is FALSE.
("Monkey" >= "Monkey") //this is TRUE.

== (equal-equal)

bool == ( string A, string B )

Takes two strings and returns true if the strings are the same. Note that this is a case sensitive compare.

Example:

("Monkey" == "Robot") //this is FALSE.
("Monkey" == "Monkey") //this is TRUE.
("Monkey" == "monkey") //this is FALSE.

= (not-equal)

bool != ( string A, string B )

Takes two strings and returns true if the strings are NOT the same. Note that this is a case sensitive compare.

Example:

("Monkey" != "Robot") //this is TRUE.
("Monkey" != "Monkey") //this is FALSE.
("Monkey" != "monkey") //this is TRUE.

~= (tilde-equal)

bool ~= ( string A, string B )

Takes two strings and returns true if the strings are the same regardless of case.

Example:

("Monkey" ~= "Robot") //this is FALSE.
("Monkey" ~= "Monkey") //this is TRUE.
("Monkey" ~= "monkey") //this is TRUE.

-= (minus-equal)

string -= ( out string A, coerce string B );

Removes all occurences of B from A and assign the result to A;

Example:

MyString = "test: this is a test";
MyString -= "test";
log(MyString); // prints: ": this is a ";

@@ Line 17: / Line 17: @@
 ===Operator precedence===
-Operator precedence controls, how tightly an operator binds its operands. A precedence value can only be specified for infix operators (pre/postfix operators bind as tightly as possible), with lower numbers binding more tightly. For example, <code>*</code> has a precedence of 16, while <code>+</code> has 20. That means <code>*</code> binds more tightly than <code>+</code>, so <code>a * b + c * d</code> is evaluated as <code>(a * b) + (c * d)</code>.
+Operator precedence controls, how tightly an operator binds its operands. A precedence value can only be specified for infix operators (pre/postfix operators bind as tightly as possible), with lower numbers binding more tightly. For example, <code>*</code> has a precedence of 16, while <code>+</code> has 20. That means <code>*</code> binds more tightly than <code>+</code>, so <code>a * b + c * d</code> is evaluated as <code>(a * b) + (c * d)</code>. It is possible to define different precedence values for overloaded operators. For example the <code>-=</code> operator as combined subtract and assign for numeric values has a precedence of 34, while the <code>-=</code> operator for removing occurrences of a string in another string has a precedence of 45.
 The following table lists the operator precedence for the default operators defined across the various engine versions. Operators further up in the table bind more tightly.
@@ Line 65: / Line 65: @@
 u = v * f * g;
 </uscript>
-This code evaluates as <code>(v * f) * g</code>, that means both operators are <code>vector * float</code>. If this was written as <code>v * (f * g)</code>, the second operator would actually be <code>float * float</code>. It doesn't matter much for the result in this case, but you will have to keep this effect in mind for [[int]] operations like division or bit shifting, which are usually not reversible. For example the expression <code>i / n * n</code> returns the largest multiple of n that is less than or equal to i if both variables are declared of type int.
+This code evaluates as <code>(v * f) * g</code>, that means both operators are <code>vector * float</code>. If this was written as <code>v * (f * g)</code>, the second operator would actually be <code>float * float</code>. It doesn't matter much for the result in this case, but you will have to keep this effect in mind for [[int]] operations like division or bit shifting. For these operations it matters which order you perform the operations. For example the expression <code>i / n * n</code> returns the largest multiple of n that is less than or equal to i if both variables are declared of type int, while <code>i * n / n</code> results in i again.
 You might find the left-associativity counter-intuitive if you want to do something like:
@@ Line 134: / Line 134: @@
 </uscript>
-In [[Unreal Engine 2]] the newly created object receives a call to its ''Created()'' function before the <code>new</code> operator returns.
+Only in [[Unreal Engine 2]] the newly created object receives a call to its ''Created()'' function before the <code>new</code> operator returns. Other engine generations do not provide any generic initialization events.
 {{navbox unrealscript}}

@@ Line 33: / Line 33: @@
 |align="center"| 20 || <code>+</code>, <code>-</code> || addition, subtraction
 |-
-|align="center"| 22 || <code><<</code>, <code>>></code>, <code>>>></code> || [[wp:Bitwise operation#Bit_shifts|bit shifting]], vector transformation
+|align="center"| 22 || <code><<</code>, <code>>></code>, <code>>>></code> || [[wp:Bitwise operation#Bit_shifts|bit shifting]], [[vector]] transformation
 |-
 |align="center"| 24 || <code><</code>, <code>></code>, <code><=</code>, <code>>=</code>, <code>==</code>, <code>~=</code>, <code>ClockwiseFrom</code> || comparison

@@ Line 104: / Line 104: @@
 Arguments:
 ; outer : The value for the new object's Outer variable. The default value is <code>None</code>, which means the object is created within the "transient package", a virtual package for runtime objects.<br/>If the class to create an object from is declared [[within]] another class, then the ''outer'' argument must be an object of that class or a subclass.
-; name : The name for the new object. In [[Unreal Engine 2]] this must be a [[string]], other engine generations expect a [[name]] here. Leaving the name empty assigns a default name consisting of the class name and a number. Unreal Engine 2 might not append the number unless the engine was started with the commandline parameter <code>-makenames</code>. Specifying the name of an existing object of the same class within the same outer object may have unexpected results if the existing object is still in use as it will be replaced by the new object.
+; name : The name for the new object. [[Unreal Engine 1]] expects a [[name]] value here, but starting with [[Unreal Engine 2]] this must be a [[string]] value. Omitting the name or passing "None" or the empty string assigns a default name consisting of the class name and a number, in [[Unreal Engine 3]] separated by an underscore character. Unreal Engine 2 might not append the number unless the engine was started with the commandline parameter <code>-makenames</code>. Specifying the name of an existing object of the same class within the same outer object may have unexpected results if the existing object is still in use as it will be replaced by the new object.
 ; flags : Specifies object flags for the new object. Only use this if you know what you're doing!
 ; class : The class to create an object of. The specified class must not be [[abstract]] or extend [[Actor]]. (Actors must be created with the [[Spawn() function]].)

@@ Line 76: / Line 76: @@
 ==Special operators==
 ===Assignment operator===
 The assignment operator <code>=</code> implicitly exists for all possible data types, except [[static arrays]]. It could informally be described with the following declaration:
@@ Line 99: / Line 101: @@
 ===New operator===
 The special operator <code>new</code> can be used to create non-[[Actor]] objects. In its simplest form it works like a prefix operator, but it can also take additional parameters similar to a [[function call]]. The general syntax for using the <code>new</code> operator is as follows:
-  '''new''' ['''(''' ''outer'' [''',''' ''name'' [''',''' ''flags'']] ''')'''] ''class'' ['''(''' ''template'' ''')''']
+  '''new''' ['''(''' [''outer'' [''',''' ''name'' [''',''' ''flags'']]] ''')'''] ''class'' ['''(''' ''template'' ''')''']
 Arguments:
 ; outer : The value for the new object's Outer variable. The default value is <code>None</code>, which means the object is created within the "transient package", a virtual package for runtime objects.<br/>If the class to create an object from is declared [[within]] another class, then the ''outer'' argument must be an object of that class or a subclass.
@@ Line 113: / Line 115: @@
 O = new(None, 'ExampleObject') class'TestClass'; // O.Name == 'ExampleObject'
 O = new(None, '', RF_Transient) class'TestClass'; // makes O transient even if TestClass isn't
-O = new(None, '', 0) class'TestClass' (TestClass'TemplateObject'); // duplicates ExmapleObject
+O = new(None, '', 0) class'TestClass' (TestClass'TemplateObject'); // duplicates TemplateObject
 </uscript>
-The return type of the <code>new</code> operator corresponds to the metatype of the specified class argument:
+The (compile-time) return type of the <code>new</code> operator corresponds to the (compile-time) metatype of the specified class argument:
 <uscript>
 local class<WebApplication> WAClass;

@@ Line 16: / Line 16: @@
 Operators can be overloaded, that means multiple operators with the same name or symbol can be defined, as long as they differ in their operand types. Overloading with identical operand types is not allowed as the engine would not be able to distinguish between the definitions.
-===Operator precedence and associativity===
+===Operator precedence===
-To make it short, all regular infix operators of the same precedence are [[wp:Operator associativity|left-associative]] and there's no way to change that. <code>a + b + c + d</code> is always evaluated as <code>((a + b) + c) + d</code>. While this doesn't change the general evaluation order of the operands, it may have an impact on the type of operation and the result. For example, consider the following code:
-<uscript>
-local vector u, v;
-local float f, g;
-−
-u = v * f * g;
-</uscript>
-This code evaluates as <code>(v * f) * g</code>, that means both operators are <code>vector * float</code>. If this was written as <code>v * (f * g)</code>, the second operator would actually be <code>float * float</code>. It doesn't matter much for the result in this case, but you will have to keep this effect in mind for int operations where, for example, division or bit shifting.
-−
 Operator precedence controls, how tightly an operator binds its operands. A precedence value can only be specified for infix operators (pre/postfix operators bind as tightly as possible), with lower numbers binding more tightly. For example, <code>*</code> has a precedence of 16, while <code>+</code> has 20. That means <code>*</code> binds more tightly than <code>+</code>, so <code>a * b + c * d</code> is evaluated as <code>(a * b) + (c * d)</code>.
@@ Line 65: / Line 56: @@
 |}
 Note that string operations, bitwise integer operations and logical AND, OR and XOR bind less tightly than comparison operators. See {{classgames|Object operators}} for detailed descriptions of the operators.
 ==Special operators==