Arma Reforger:Scripting: Operators - Revision history

Lou Montana: Add <<=, >>= operators and sign extension warning

2025-07-24T19:25:59Z

Add <<=, >>= operators and sign extension warning

← Older revision		Revision as of 21:25, 24 July 2025
Line 186:		Line 186:

	<div style="font-family: monospace">		<div style="font-family: monospace">
	==== {{=}} ====		==== = ====
	</div>		</div>
	The "assign" operator sets the righthand value to the lefthand variable.		The "assign" operator sets the righthand value to the lefthand variable.
Line 248:		Line 248:

	<div style="font-family: monospace">		<div style="font-family: monospace">
	==== +{{=}} ====		==== += ====
	</div>		</div>
	The "add to" operator adds the righthand value to the lefthand variable.		The "add to" operator adds the righthand value to the lefthand variable.
Line 257:		Line 257:

	<div style="font-family: monospace">		<div style="font-family: monospace">
	==== -{{=}} ====		==== -= ====
	</div>		</div>
	The "subtract from" operator subtract the righthand value to the lefthand variable.		The "subtract from" operator subtract the righthand value to the lefthand variable.
Line 266:		Line 266:

	<div style="font-family: monospace">		<div style="font-family: monospace">
	==== *{{=}} ====		==== *= ====
	</div>		</div>
	The "multiply with" operator multiplies the lefthand variable with the righthand value.		The "multiply with" operator multiplies the lefthand variable with the righthand value.
Line 275:		Line 275:

	<div style="font-family: monospace">		<div style="font-family: monospace">
	==== /{{=}} ====		==== /= ====
	</div>		</div>
	The "divide by" operator multiplies the lefthand variable with the righthand value.		The "divide by" operator multiplies the lefthand variable with the righthand value.
Line 282:		Line 282:
	result /= 3; // result is 1 (floored int value)		result /= 3; // result is 1 (floored int value)
	</enforce>		</enforce>

			<div style="font-family: monospace">
			==== <<= ====
			</div>
			The "left-offset by" operator offsets the lefthand variable to the left by the righthand value.
			<enforce>
			int result = 0x0000FF32;
			result <<= 8; // result is 0x00FF3200
			</enforce>

			<div style="font-family: monospace">
			==== >>= ====
			</div>
			The "right-offset by" operator offsets the lefthand variable to the right by the righthand value.
			<enforce>
			int result = 0x00FF3200;
			result >>= 8; // result is 0x0000FF32
			</enforce>
			{{Feature\|important\|
			Beware of {{Link\|https://en.wikipedia.org/wiki/Sign_extension\|sign extension}}:
			<enforce>
			int result = 0x80000000;
			result >>= 8; // result is 0x<u>'''FF'''</u>800000
			</enforce>
			}}

	=== Arithmetic ===		=== Arithmetic ===
Line 372:		Line 397:

	<div style="font-family: monospace">		<div style="font-family: monospace">
	==== >{{=}} ====		==== >= ====
	</div>		</div>
	The "greater than or equal" operator returns '''true''' if the left argument is greater than or equal to the right argument, false otherwise.<br>		The "greater than or equal" operator returns '''true''' if the left argument is greater than or equal to the right argument, false otherwise.<br>
Line 387:		Line 412:

	<div style="font-family: monospace">		<div style="font-family: monospace">
	==== <{{=}} ====		==== <= ====
	</div>		</div>
	The "lesser than or equal" operator returns '''true''' if the left argument is smaller than or equal to the right argument, false otherwise.<br>		The "lesser than or equal" operator returns '''true''' if the left argument is smaller than or equal to the right argument, false otherwise.<br>
Line 402:		Line 427:

	<div style="font-family: monospace">		<div style="font-family: monospace">
	==== {{=~~}}{{~~=}} ====		==== == ====
	</div>		</div>
	The "equals" operator returns '''true''' if the left argument is strictly equal to the right argument, false otherwise.		The "equals" operator returns '''true''' if the left argument is strictly equal to the right argument, false otherwise.
Line 436:		Line 461:

	<div style="font-family: monospace">		<div style="font-family: monospace">
	==== !{{=}} ====		==== != ====
	</div>		</div>
	The "different" operator returns '''true''' if the left argument is different from the right argument, false otherwise.		The "different" operator returns '''true''' if the left argument is different from the right argument, false otherwise.

Lou Montana: Fix

2025-04-11T10:44:19Z

Fix

← Older revision		Revision as of 12:44, 11 April 2025
Line 188:		Line 188:
	==== {{=}} ====		==== {{=}} ====
	</div>		</div>
	The "assign operator sets the righthand value to the lefthand variable.		The "assign" operator sets the righthand value to the lefthand variable.
	<enforce>		<enforce>
	int five = 5;		int five = 5;

Lou Montana: Text replacement - "\{\{GameCategory\|armaR\|Modding\|(Guidelines|Tutorials)\|([^=↵]*)\}\}" to "{{GameCategory|armaR|Modding|$2|$1}}"

2025-02-26T12:32:06Z

Text replacement - "\{\{GameCategory\|armaR\|Modding\|(Guidelines|Tutorials)\|([^=↵]*)\}\}" to "{{GameCategory|armaR|Modding|$2|$1}}"

← Older revision		Revision as of 14:32, 26 February 2025
Line 688:		Line 688:


	{{GameCategory\|armaR\|Modding\|Guidelines~~\|Scripting~~}}		{{GameCategory\|armaR\|Modding\|Scripting\|Guidelines}}

Lou Montana: Remove infobox about precedence since the precedence table has been moved at the top

2024-05-17T10:04:25Z

Remove infobox about precedence since the precedence table has been moved at the top

← Older revision		Revision as of 12:04, 17 May 2024
Line 1:		Line 1:
	{{TOC\|side}}		{{TOC\|side}}
	'''Operators''' are elements used to generate operations between two values.		'''Operators''' are elements used to generate operations between two values.
	~~{{Feature\|informative\|Operators have a '''precedence''' order; see {{Link\|#Precedence}} section below for more information.}}~~

	{{TOC\|subtoc\|content=		{{TOC\|subtoc\|content=

Lou Montana: Some wiki formatting

2024-05-17T10:02:09Z

Some wiki formatting

Show changes

Lou Montana: Fix PHP interferences, Some wiki formatting

2023-06-20T21:32:14Z

Fix PHP interferences, Some wiki formatting

← Older revision		Revision as of 23:32, 20 June 2023
Line 133:		Line 133:
	The multiplication sign does a multiplication between two numerical values, float and/or integer.		The multiplication sign does a multiplication between two numerical values, float and/or integer.
	<enforce>		<enforce>
	5 * 3; // result is 15		5 * 3; // result is 15
	5 * 2.5; // result is 12.5 (float)		5 * 2.5; // result is 12.5 (float)
	1.5 * 3.25; // result is 4.875 (float)		1.5 * 3.25; // result is 4.875 (float)
	</enforce>		</enforce>

Line 145:		Line 145:
	If both values are int, the return value will be a '''floored''' integer as well.		If both values are int, the return value will be a '''floored''' integer as well.
	<enforce>		<enforce>
	5 / 3; // result is 1 (int): 5/3 = 1.666(...), but integer floors the value		5 / 3; // result is 1 (int): 5/3 = 1.666(...), but integer floors the value
	5 / 2.5; // result is 2.0 (float)		5 / 2.5; // result is 2.0 (float)
	3.5 / 0.5; // result is 7.0 (float)		3.5 / 0.5; // result is 7.0 (float)
	</enforce>		</enforce>

Line 157:		Line 157:
	{{Feature\|informative\|See the <enforce inline>Math.Repeat()</enforce> method for a float modulo approximation.}}		{{Feature\|informative\|See the <enforce inline>Math.Repeat()</enforce> method for a float modulo approximation.}}
	<enforce>		<enforce>
	5 % 3; // result is 2: 5 is one time 3, remaining 2		5 % 3; // result is 2: 5 is one time 3, remaining 2
	10 % 2; // result is 0: 10 is five times 2, remaining 0		10 % 2; // result is 0: 10 is five times 2, remaining 0
	</enforce>		</enforce>

Line 170:		Line 170:
	It can be applied to int, float or a mix of those.		It can be applied to int, float or a mix of those.
	<enforce>		<enforce>
	10 > 11; // false		10 > 11; // false
	10 > 10; // false		10 > 10; // false
	10 > 9; // true		10 > 9; // true

	10 > 5; // true		10 > 5; // true
	10 > 5.5; // true		10 > 5.5; // true
	10.5 > 5; // true		10.5 > 5; // true
	</enforce>		</enforce>

Line 185:		Line 185:
	It can be applied to int, float or a mix of those.		It can be applied to int, float or a mix of those.
	<enforce>		<enforce>
	10 < 11; // true		10 < 11; // true
	10 < 10; // false		10 < 10; // false
	10 < 9; // false		10 < 9; // false

	10 < 5; // false		10 < 5; // false
	10 < 5.5; // false		10 < 5.5; // false
	10.5 < 5; // false		10.5 < 5; // false
	</enforce>		</enforce>

Line 200:		Line 200:
	It can be applied to int, float or a mix of those.		It can be applied to int, float or a mix of those.
	<enforce>		<enforce>
	10 >= 11; // false		10 >= 11; // false
	10 >= 10; // true		10 >= 10; // true
	10 >= 9; // true		10 >= 9; // true

	10 >= 5; // true		10 >= 5; // true
	10 >= 5.5; // true		10 >= 5.5; // true
	10.5 >= 5; // true		10.5 >= 5; // true
	</enforce>		</enforce>

Line 215:		Line 215:
	It can be applied to int, float or a mix of those.		It can be applied to int, float or a mix of those.
	<enforce>		<enforce>
	10 <= 11; // true		10 <= 11; // true
	10 <= 10; // true		10 <= 10; // true
	10 <= 9; // false		10 <= 9; // false

	10 <= 5; // false		10 <= 5; // false
	10 <= 5.5; // false		10 <= 5.5; // false
	10.5 <= 5; // false		10.5 <= 5; // false
	</enforce>		</enforce>

Line 346:		Line 346:

	int health = 0;		int health = 0;
	if (!health) // same as if (health == 0)		if (!health) // same as if (health == 0) - not recommended
	{
	Print("dead");		Print("dead");
	}

	float fHealth = 0.0;		float fHealth = 0.0;
	if (!fHealth) // same as if (fHealth == 0)		if (!fHealth) // same as if (fHealth == 0) - not recommended
	{
	Print("dead");		Print("dead");
	}

	string data = "";		string data = "";
	if (!data) // same as if (data.IsEmpty()) and if (data == "")		if (!data) // same as if (data.IsEmpty()) and if (data == "") - not recommended
	{
	Print("empty string");		Print("empty string");
	}

	MyClass instance = null;		MyClass instance = null;
	if (!instance) // same as if (instance == null)		if (!instance) // same as if (instance == null)
	{
	Print("instance is null!");		Print("instance is null!");
	}

	// note that if (value) to check an object is -not- null works too		// note that if (value) to check an object is -not- null works too
	if (instance) // same as if (instance != null)		if (instance) // same as if (instance != null)
	{
	Print("instance is NOT null!");		Print("instance is NOT null!");
	}
	</enforce>		</enforce>

Line 496:		Line 486:
	Print("#" + i + " is empty");		Print("#" + i + " is empty");
	else		else
	Print("trimmed '" + myArray[i] + "' is '" + myArray[i].Trim() . "'"); // .Get(i) equivalent, twice		Print("trimmed '" + myArray[i] + "' is '" + myArray[i].Trim() + "'"); // .Get(i) equivalent, twice
	}		}

Line 506:		Line 496:
	Print("#" + i + " is empty");		Print("#" + i + " is empty");
	else		else
	Print("trimmed '" + value + "' is '" + value.Trim() . "'");		Print("trimmed '" + value + "' is '" + value.Trim() + "'");
	}		}

Line 515:		Line 505:
	Print("#" + i + " is empty");		Print("#" + i + " is empty");
	else		else
	Print("trimmed '" + value + "' is '" + value.Trim() . "'");		Print("trimmed '" + value + "' is '" + value.Trim() + "'");
	}		}
	</enforce>		</enforce>

Lou Montana: Fix boolean → bool

2023-06-16T22:16:57Z

Fix boolean → bool

← Older revision		Revision as of 00:16, 17 June 2023
Line 230:		Line 230:

	Applies to:		Applies to:
	* ~~boolean~~		* bool
	* int		* int
	* float		* float
Line 264:		Line 264:

	Applies to:		Applies to:
	* ~~boolean~~		* bool
	* int		* int
	* float		* float
Line 296:		Line 296:
	The "and" operator returns '''true''' if both left and right conditions are true.		The "and" operator returns '''true''' if both left and right conditions are true.
	<enforce>		<enforce>
	~~boolean~~ a = false;		bool a = false;
	~~boolean~~ b = false;		bool b = false;
	~~boolean~~ result = a && b; // result is false		bool result = a && b; // result is false

	~~boolean~~ a = true;		bool a = true;
	~~boolean~~ b = false;		bool b = false;
	~~boolean~~ result = a && b; // result is false		bool result = a && b; // result is false

	~~boolean~~ a = true;		bool a = true;
	~~boolean~~ b = true;		bool b = true;
	~~boolean~~ result = a && b; // result is true		bool result = a && b; // result is true
	</enforce>		</enforce>

Line 314:		Line 314:
	The "or" logical operator returns '''true''' if left or right condition is true (or both).		The "or" logical operator returns '''true''' if left or right condition is true (or both).
	<enforce>		<enforce>
	~~boolean~~ a = false;		bool a = false;
	~~boolean~~ b = false;		bool b = false;
	~~boolean~~ result = a \|\| b; // result is false		bool result = a \|\| b; // result is false

	~~boolean~~ a = true;		bool a = true;
	~~boolean~~ b = false;		bool b = false;
	~~boolean~~ result = a \|\| b; // result is true		bool result = a \|\| b; // result is true

	~~boolean~~ a = true;		bool a = true;
	~~boolean~~ b = true;		bool b = true;
	~~boolean~~ result = a \|\| b; // result is true		bool result = a \|\| b; // result is true
	</enforce>		</enforce>

Line 330:		Line 330:
	==== ! ====		==== ! ====
	</div>		</div>
	The "not" logical operator inverts a ~~boolean~~ value: {{hl\|true}} becomes {{hl\|false}} and {{hl\|false}} becomes {{hl\|true}}.<br>		The "not" logical operator inverts a bool value: {{hl\|true}} becomes {{hl\|false}} and {{hl\|false}} becomes {{hl\|true}}.<br>
	It can also be used on:		It can also be used on:
	* int or float (0 comparison)		* int or float (0 comparison)
Line 336:		Line 336:
	* object (null comparison)		* object (null comparison)
	<enforce>		<enforce>
	~~boolean~~ a = true;		bool a = true;
	~~boolean~~ result = !a; // result is false		bool result = !a; // result is false

	~~boolean~~ a = false;		bool a = false;
	~~boolean~~ result = !a; // result is true		bool result = !a; // result is true

	~~boolean~~ isAlive = player.IsAlive();		bool isAlive = player.IsAlive();
	~~boolean~~ isDead = !isAlive;		bool isDead = !isAlive;

	int health = 0;		int health = 0;
Line 450:		Line 450:
	string result = a + " " + b; // result is "Hello there"		string result = a + " " + b; // result is "Hello there"

	string ~~stringifiedBoolean~~ = "string " + true; // result is "string true"		string stringifiedBool = "string " + true; // result is "string true"
	string stringifiedInt = "string " + 42; // result is "string 42"		string stringifiedInt = "string " + 42; // result is "string 42"
	string stringifiedFloat = "string " + 4.0; // result is "string 4"		string stringifiedFloat = "string " + 4.0; // result is "string 4"

Lou Montana: Some wiki formatting

2023-06-16T20:46:58Z

Some wiki formatting

← Older revision		Revision as of 22:46, 16 June 2023
Line 490:		Line 490:
	in order to save unrequired method calls, either use {{Link\|Arma Reforger:Scripting: Keywords#foreach\|foreach}} or cache the call result whenever possible.		in order to save unrequired method calls, either use {{Link\|Arma Reforger:Scripting: Keywords#foreach\|foreach}} or cache the call result whenever possible.
	<enforce>		<enforce>
			// bad
	for (int i, count = myArray.Count(); i < count; i++)		for (int i, count = myArray.Count(); i < count; i++)
	{		{
Line 497:		Line 498:
	Print("trimmed '" + myArray[i] + "' is '" + myArray[i].Trim() . "'"); // .Get(i) equivalent, twice		Print("trimmed '" + myArray[i] + "' is '" + myArray[i].Trim() . "'"); // .Get(i) equivalent, twice
	}		}
	</~~enforce>~~
	~~<enforce>~~		// good
	for (int i, count = myArray.Count(); i < count; i++)		for (int i, count = myArray.Count(); i < count; i++)
	{		{
Line 507:		Line 508:
	Print("trimmed '" + value + "' is '" + value.Trim() . "'");		Print("trimmed '" + value + "' is '" + value.Trim() . "'");
	}		}
	</~~enforce>~~
	~~<enforce>~~		// best
	foreach (int i, string value : myArray)		foreach (int i, string value : myArray)
	{		{

Lou Montana: Add static arrays specificity

2023-06-16T20:29:31Z

Add static arrays specificity

← Older revision		Revision as of 22:29, 16 June 2023
Line 470:		Line 470:
	==== <nowiki>[]</nowiki> ====		==== <nowiki>[]</nowiki> ====
	</div>		</div>
	The "get index" operator is used on arrays to get an element by its '''zero-based''' index (e.g 0 is first element, 1 is second, etc).		The "get index" operator is used on arrays to get an element by its '''zero-based''' index (e.g 0 is first element, 1 is second, etc). It is '''very''' efficient on '''static''' arrays.
	It can also be used on strings, as strings are arrays of characters.		It can also be used on strings, as strings are arrays of characters.
	<enforce>		<enforce>
			int staticNumbers[5] = { 1, 2, 3, 4, 5 };
			int thirdStaticNumber = staticNumbers[2]; // result is 3, lightning fast on static arrays

	array<int> numbers = { 1, 2, 3, 4, 5 };		array<int> numbers = { 1, 2, 3, 4, 5 };
	int thirdNumber = letters[2]; // result is 3		int thirdNumber = letters[2]; // result is 3

	array<string> letters = { "A", "B", "C", "D", "E" };		array<string> letters = { "A", "B", "C", "D", "E" };
	string thirdLetter = letters[2]; // result is "C"		string thirdLetter = letters[2]; // result is "C"

	string text = "ABCDE";		string text = "ABCDE";
	string thirdLetter = text[2]; // result is "C"		string thirdLetter = text[2]; // result is "C"
	</enforce>		</enforce>

	{{Feature\|important\|		{{Feature\|important\|
	The {{hl\|[i]}} operator is equivalent to a <enforce inline>.Get(i)</enforce> method call; in order to save unrequired method calls, either use {{Link\|Arma Reforger:Scripting: Keywords#foreach\|foreach}} or cache the call result whenever possible.		The {{hl\|[i]}} operator is equivalent to a <enforce inline>.Get(i)</enforce> method call for anything else than static arrays;
			in order to save unrequired method calls, either use {{Link\|Arma Reforger:Scripting: Keywords#foreach\|foreach}} or cache the call result whenever possible.
	<enforce>		<enforce>
	for (int i, count = myArray.Count(); i < count; i++)		for (int i, count = myArray.Count(); i < count; i++)

Lou Montana: Add ++i & --i, Change h4 font, Add xxx[i] note & example

2023-06-16T19:47:49Z

Add ++i & --i, Change h4 font, Add xxx[i] note & example

Show changes