+: Difference between revisions

From Bohemia Interactive Community
Jump to navigation Jump to search
m (Text replacement - "\[\[Category:[ _]?Scripting[ _]Commands[ _]Armed[ _]Assault(\|.*)]]" to "{{GameCategory|arma1|Scripting Commands}}")
m (Text replacement - "(\|[pr][0-9]+ *= *[^- ]*) *- *T([a-z ])" to "$1 - t$2")
 
(41 intermediate revisions by 3 users not shown)
Line 1: Line 1:
{{Command|Comments=
{{RV|type=command


| ofp |Game=
|sortKey= #


|1.00|Game Version (number surrounded by NO SPACES)=
|game1= ofp
|version1= 1.00


|arg= |Multiplayer Arguments ("local" or "global")=
|game2= ofpe
|version2= 1.00


|eff= |Multiplayer Effects ("local" or "global")=
|game3= arma1
|version3= 1.00


|serverExec= |Multiplayer Execution ("server" or empty)=
|game4= arma2
|version4= 1.00


|gr1= Math |GROUP1=
|game5= arma2oa
|version5= 1.50


| Add two numbers, concatenate two arrays or two strings, or duplicate an array. For arrays also see [[pushBack]] and [[append]].  
|game6= tkoh
|version6= 1.00


{{Warning | [[Array]] copy methods <tt>ARRAY + []</tt> and <tt>+ARRAY</tt> have different behaviours:
|game7= arma3
* <tt>ARRAY + []</tt> creates copy of the 1st dimension, but preserves references in other dimensions ({{Wikipedia|Object copying#Shallow copy|shallow copy}}).
|version7= 0.50
* <tt>+ARRAY</tt> clones every element, so if the array is multi-dimensional, the created copy contains no references ({{Wikipedia|Object copying#Deep copy|deep copy}}).
See [[#Examples|Example 6]].}} |Description=


| numberA [[+]] numberB |Syntax=
|gr1= Math


|p1= numberA: [[Number]] |Parameter 1=
|gr2= Arrays


|p2= numberB: [[Number]] |Parameter 2=
|gr3= HashMap


| [[Number]] - the sum of ''numberA'' and ''numberB'' |Return Value=
|gr4= Strings


|s2= [[+]] numberA |Alternative Syntax=
|descr= Add two [[Number]]s, concatenate two [[Array]]s or two [[String]]s, or create a copy of an Array or [[HashMap]].


|p21= numberA: [[Number]] |Alternative Parameter 1=
{{Feature|warning|[[Array]] copy methods {{hl|ARRAY + []}} and {{hl|+ ARRAY}} have different behaviours:
* {{hl|ARRAY + []}} creates copy of the 1st dimension, but preserves references in other dimensions ({{Link|https://en.wikipedia.org/wiki/Object_copying#Shallow_copy|shallow copy}}).
* {{hl|+ ARRAY}} clones every element, so if the array is multi-dimensional, the created copy contains no references ({{Link|https://en.wikipedia.org/wiki/Object_copying#Deep_copy|deep copy}}).
See [[#Example_6|Example 6]].
}}
 
|s1= numberA [[+]] numberB
 
|p1= numberA: [[Number]]


|r2= [[Number]] - returns ''numberA'' |Alternative Return Value=
|p2= numberB: [[Number]]


|s3= arrayA [[+]] arrayB |Alternative Syntax 3=
|r1= [[Number]] - the sum of ''numberA'' and ''numberB''


|p41= arrayA: [[Array]] |Alternative 3 Parameter 1=
|s2= [[+]] number


|p42= arrayB: [[Array]] |Alternative 3 Parameter 2=
|p21= number: [[Number]]


|r3= [[Array]] - a new array filled with ''arrayA'' and ''arrayB'' elements, in that order. |Alternative 3 Return Value=
|r2= [[Number]] - the value of the parameter ''number''


|s4= stringA [[+]] stringB |Alternative Syntax 4=
|s3= arrayA [[+]] arrayB


|p61= stringA: [[String]] |Alternative 4 Parameter 1=
|p41= arrayA: [[Array]]


|p62= stringB: [[String]] |Alternative 4 Parameter 2=
|p42= arrayB: [[Array]]


|r4= [[String]] - a string concatenating ''stringA'' and ''stringB'' |Alternative 4 Return Value=
|r3= [[Array]] - a new array filled with ''arrayA'' and ''arrayB'' elements, in that order


|s5= [[+]] arrayA |Alternative Syntax 5=
|s4= stringA [[+]] stringB


|p81= arrayA: [[Array]] |Alternative 5 Parameter 1=
|p61= stringA: [[String]]


|r5= [[Array]] - a new instance of array filled with same items. |Alternative 5 Return Value=
|p62= stringB: [[String]]


|x1= <code> 5 [[+]] 3; {{codecomment|// returns 8}}
|r4= [[String]] - a string concatenating ''stringA'' and ''stringB''
-5 [[+]] -3; {{codecomment|// returns -8}}</code> |Example 1=


|x2= <code>[[+]] 2; {{codecomment|// returns  2}}
|s5= [[+]] array
[[+]] -7; {{codecomment|// returns -7}}</code> |Example 2=


|x3= <code>_arrayA = [1,2,3];
|p81= array: [[Array]]
_arrayB = [3,4,5];
 
_arrayAB = _arrayA + _arrayB; {{codecomment|// _arrayAB {{=}} [1,2,3,3,4,5]
|r5= [[Array]] - a new instance of the provided array filled with same elements ({{Link|https://en.wikipedia.org/wiki/Object_copying#Deep_copy|deep copy}})
// _arrayA and _arrayB remain unchanged}}</code> |Example 3=
 
|s6= [[+]] hashMap
 
|s6since= arma3 2.04
 
|p101= hashMap: [[HashMap]]
 
|r6= [[HashMap]] - a new instance of the provided [[HashMap]] filled with the same key-value pairs ({{Link|https://en.wikipedia.org/wiki/Object_copying#Deep_copy|deep copy}})
 
|x1= <sqf notrim>
5 +  3 // returns  8
-5 + -3 // returns -8
</sqf>


|x4= <code>_result = "Hello" + " " + "there"; {{codecomment|// "Hello there"}}</code> |Example 4=
|x2= <sqf>
+ 2 // returns  2
+ -7 // returns -7
</sqf>


|x5= <code>_arrayA = [1,2,3];
|x3= <sqf>
_arrayB = +_arrayA;
_arrayA = [1,2,3];
_arrayB [[set]] [0, 99]; {{codecomment|// _arrayA {{=}} [1,2,3], _arrayB {{=}} [99,2,3]}}</code> |Example 5=
_arrayB = [3,4,5];
_arrayAB = _arrayA + _arrayB; // _arrayAB = [1,2,3,3,4,5]
// _arrayA and _arrayB remain unchanged
</sqf>


|x6= Shallow copy with <tt>ARRAY + []</tt>:
|x4= <sqf>_result = "Hello" + " " + "there"; // "Hello there"</sqf>
<code>[[private]] _subArray {{=}} [1, 2, 3];
[[private]] _array1 {{=}} [_subArray, 1, 2, 3];
[[private]] _array2 {{=}} _array1 + [];
_array2 [[select]] 0 [[set]] [0, "oops"];
[[hint]] [[str]] _subArray; {{cc|["oops", 2, 3]}}</code>
Deep copy with <tt>+ARRAY</tt>:
<code>[[private]] _subArray {{=}} [1, 2, 3];
[[private]] _array1 {{=}} [_subArray, 1, 2, 3];
[[private]] _array2 {{=}} +_array1;
_array2 [[select]] 0 [[set]] [0, "oops"];
[[hint]] [[str]] _subArray; {{cc|[1, 2, 3]}}</code> |Example 6=


| [[Operators]], [[pushBack]], [[append]] |See Also=
|x5= <sqf>
}}
_arrayA = [1,2,3];
_arrayB = + _arrayA;
_arrayB set [0, 99]; // _arrayA = [1,2,3], _arrayB = [99,2,3]
</sqf>


<dl class="command_description">
|x6= Shallow copy with {{hl|ARRAY + []}}:
<!-- BEGIN Note Section -->
<sqf>
<!-- END Note Section -->
private _subArray = [1, 2, 3];
</dl>
private _array1 = [_subArray, 1, 2, 3];
private _array2 = _array1 + [];
_array2 select 0 set [0, "oops"];
hint str _subArray; // ["oops", 2, 3]
</sqf>


<h3 style="display:none">Bottom Section</h3>
Deep copy with {{hl|+ ARRAY}}:
<!-- Appropriate categories go here -->
<sqf>
private _subArray = [1, 2, 3];
private _array1 = [_subArray, 1, 2, 3];
private _array2 = + _array1;
_array2 select 0 set [0, "oops"];
hint str _subArray; // [1, 2, 3]
</sqf>


[[Category:Scripting Commands|#]]
|seealso= [[Operators]] [[pushBack]] [[append]] [[merge]]
[[Category:Scripting Commands OFP 1.99|#]]
}}
[[Category:Scripting Commands OFP 1.96|#]]
[[Category:Scripting Commands OFP 1.46|#]]
{{GameCategory|arma1|Scripting Commands}}
[[Category:Scripting Commands Arma 2|#]]
[[Category:Scripting Commands Arma 3|#]]

Latest revision as of 15:51, 8 November 2023

Logo A0.png1.00ofpe logo.png1.00Logo A1 black.png1.00Logo A2.png1.00A2 OA Logo.png1.50tkoh logo small.png1.00Arma 3 logo black.png0.50
Hover & click on the images for description

Description

Description:
Add two Numbers, concatenate two Arrays or two Strings, or create a copy of an Array or HashMap.
⚠
Array copy methods ARRAY + [] and + ARRAY have different behaviours:
  • ARRAY + [] creates copy of the 1st dimension, but preserves references in other dimensions (shallow copy).
  • + ARRAY clones every element, so if the array is multi-dimensional, the created copy contains no references (deep copy).
See Example 6.
Groups:
MathArraysHashMapStrings

Syntax 1

Syntax:
numberA + numberB
Parameters:
numberA: Number
numberB: Number
Return Value:
Number - the sum of numberA and numberB

Syntax 2

Syntax:
+ number
Parameters:
number: Number
Return Value:
Number - the value of the parameter number

Syntax 3

Syntax:
arrayA + arrayB
Parameters:
arrayA: Array
arrayB: Array
Return Value:
Array - a new array filled with arrayA and arrayB elements, in that order

Syntax 4

Syntax:
stringA + stringB
Parameters:
stringA: String
stringB: String
Return Value:
String - a string concatenating stringA and stringB

Syntax 5

Syntax:
+ array
Parameters:
array: Array
Return Value:
Array - a new instance of the provided array filled with same elements (deep copy)

Syntax 6

Syntax:
+ hashMap
Parameters:
hashMap: HashMap
Return Value:
HashMap - a new instance of the provided HashMap filled with the same key-value pairs (deep copy)

Examples

Example 1:
5 + 3 // returns 8 -5 + -3 // returns -8
Example 2:
+ 2 // returns 2 + -7 // returns -7
Example 3:
_arrayA = [1,2,3]; _arrayB = [3,4,5]; _arrayAB = _arrayA + _arrayB; // _arrayAB = [1,2,3,3,4,5] // _arrayA and _arrayB remain unchanged
Example 4:
_result = "Hello" + " " + "there"; // "Hello there"
Example 5:
_arrayA = [1,2,3]; _arrayB = + _arrayA; _arrayB set [0, 99]; // _arrayA = [1,2,3], _arrayB = [99,2,3]
Example 6:
Shallow copy with ARRAY + []:
private _subArray = [1, 2, 3]; private _array1 = [_subArray, 1, 2, 3]; private _array2 = _array1 + []; _array2 select 0 set [0, "oops"]; hint str _subArray; // ["oops", 2, 3]
Deep copy with + ARRAY:
private _subArray = [1, 2, 3]; private _array1 = [_subArray, 1, 2, 3]; private _array2 = + _array1; _array2 select 0 set [0, "oops"]; hint str _subArray; // [1, 2, 3]

Additional Information

See also:
Operators pushBack append merge

Notes

Report bugs on the Feedback Tracker and/or discuss them on the Arma Discord or on the Forums.
Only post proven facts here! Add Note
Retrieved from "https://community.bistudio.com/wiki?title=%2B&oldid=349273"