Strings [StrJoin/String]
Mathematics
Operators and Symbols
General (Control Flow/Debugging) [PrintKeyValue]
Dates
Objects
New Features Timelines
Sections:
Any Methods
Array Methods (Array/List/Vector)
Map Methods (Map/Dictionary)
Object Methods (Object/Struct)
Range Methods
Tuple Methods (Tuple/Entry/Pair/Triple)
Optional Methods (Optional/Option/Nullable)
Set Methods
Array.ForEach Examples
Array.Map Examples
Array.Reduce Examples
Array.Filter Examples
Import/Include Tips
Language-Specific Notes
Language-Specific Notes: Java Function Objects
Note: UFL: Universal Function Library, a set of around 100-300 standard functions for all programming languages.
Languages do not have to implement anything exactly to the UFL specification, it is a guide. See lower down for further details.
Section: Any Methods
UFL: Any.Type [object type: name only]
AutoHotkey: Type(oObj)
C++: typeid(oObj).name() [e.g. 'i' for an int] [note: return values can be cryptic]
C#: oObj.GetType().Name [also (for types, not variables): typeof() e.g. typeof(int)]
Crystal: ___ [can use: oObj.class.name.split("::").last]
Excel: TYPE(A1) [also: ERROR.TYPE(A1)]
Excel VBA: TypeName(oObj) [also: TypeOf operator (which works on objects, but not primitives)]
Go: fmt.Sprintf("%T", oObj) [e.g. fmt.Printf("%T\n", oObj)]
Java: oObj.getClass().getSimpleName() [WARNING: doesn't work on primitives] [also (for types, not variables): .class e.g. int.class]
JavaScript: typeof oObj
Kotlin: oObj::class.simpleName [note: throws if var of nullable type, e.g. throws on 'Any?', works on 'Any'] [also: oObj!!::class.simpleName]
PHP: gettype($oObj)
Python: type(oObj).__name__
R: typeof(oObj) [also: class()/mode()/storage.mode()] [also: is.vector()/is.list()/length()] [WARNING: typeof(1) and typeof(c(1,2)) both return 'double'] [WARNING: length() returns the vector length, nchar() returns the string length]
Ruby: ___ [can use: oObj.class.name.split("::").last]
Rust: ___ [can use (full name): type_name_of_val(&vVar)] [requires: use std::any::type_name_of_val]
Scala: oObj.getClass().getSimpleName()
Swift: String(describing:type(of:oObj))
UFL: Any.TypeFull [object type: full name]
AutoHotkey: Object.Prototype.ToString.Call(oObj)
C++: ___ [can use: typeid(oObj).name()]
C#: oObj.GetType().FullName
Crystal: oObj.class.name
Excel: ___
Excel VBA: ___
Go: fmt.Sprintf("%T", oObj)
Java: oObj.getClass().getName() [WARNING: doesn't work on primitives] [also (for types, not variables): .class e.g. int.class] [note: '[I'/'[D' for int/double arrays respectively]
JavaScript: Object.prototype.toString.call(oObj)
Kotlin: oObj::class.qualifiedName [note: throws if var of nullable type, e.g. throws on 'Any?', works on 'Any'] [also: oObj!!::class.qualifiedName]
PHP: ___ [can use: gettype($oObj)] [also (for objects): get_class($oObj)]
Python: type(oObj)
R: typeof(oObj) [also: class()/is.vector()/is.list()/length()]
Ruby: oObj.class.name
Rust: type_name_of_val(&vVar) [requires: use std::any::type_name_of_val]
Scala: oObj.getClass().getName() [note: '[I'/'[D' for int/double arrays respectively]
Swift: String(reflecting:type(of:oObj))
UFL: (Any.TypeCustom) [object type: name only][custom function/macro 'mytype' to get the object type]
AutoHotkey: mytype := Type [can use: Type(vVar)]
C++: #define mytype(vVar) typeid(vVar).name() [note: a custom macro]
C#: public static String mytype<T>(T vVar) {return vVar.GetType().Name;}
Crystal: def mytype(vVar); vVar.class.name; end
Excel: ___ [can use: TYPE(A1)] [also: ERROR.TYPE(A1)]
Excel VBA: ___ [can use: TypeName(vVar)]
Go: func mytype[T any](vVar T) string { return fmt.Sprintf("%T", vVar) }
Java: public static <T> String mytype(T vVar) {return vVar.getClass().getSimpleName();} [WARNING: doesn't work on primitives]
JavaScript: mytype = vVar => typeof vVar
Kotlin: val mytype = {vVar: Any -> vVar::class.simpleName}
PHP: ___ [can use: gettype($vVar)]
Python: mytype = lambda vVar : type(vVar).__name__
R: mytype = typeof [also: mytype = class]
Ruby: def mytype(vVar); vVar.class.name; end
Rust: fn mytype<T>(_: T) -> &'static str {std::any::type_name::<T>()}
Scala: var mytype = (vVar:Any) => vVar.getClass().getSimpleName() [WARNING: doesn't work on nulls]
Swift: var mytype: (_ vVar: Any) -> String = {vVar in String(describing:type(of:vVar))}
UFL: Any.IsObject [is the value an object (e.g. is object: array/map, e.g. not object: 'primitive'/'value'/int/float/string/bool/null) (definitions of a primitive/value/non-object vary)][e.g. for a custom print function, which 'to string' approach to use]
AutoHotkey: vIsObj := IsObject(vVar)
C++: ___ [can use: vIsObj = !std::is_fundamental<decltype(vVar)>::value && !std::is_same<decltype(vVar),std::string>::value] [requires: #include <type_traits>]
C#: ___ [can use: vIsObj = !vVar.GetType().IsPrimitive && !(vVar is string)]
Crystal: ___ [can use: vIsObj = !(vVar.is_a?(Nil) || vVar.is_a?(Bool) || vVar.is_a?(Int) || vVar.is_a?(Float) || vVar.is_a?(Char) || vVar.is_a?(String))]
Excel: ___
Excel VBA: vIsObj = IsObject(vVar) Or IsArray(vVar)
Go: ___ [can use: reflect.TypeOf]
Java: ___ [can use (to check for non-primitive non-string): var vIsObj = !(Integer.class.isInstance(vVar) || Byte.class.isInstance(vVar) || Short.class.isInstance(vVar) || Long.class.isInstance(vVar) || Float.class.isInstance(vVar) || Double.class.isInstance(vVar) || Boolean.class.isInstance(vVar) || Character.class.isInstance(vVar) || ((Object)vVar).getClass().equals(String.class))]
JavaScript: vIsObj = (typeof vVar === "object") && (vVar !== null)
Kotlin: ___ [can use (to check for non-primitive non-string): vIsObj = (vVar::class.javaPrimitiveType == null) && (vVar !is String)]
PHP: $vIsObj = is_object($vVar) || is_array($vVar)
Python: ___ [can use: vIsObj = not isinstance(vVar, str|int|float|None)] [note: bool is a subclass of int (i.e. int covers int and bool), e.g. 'isinstance(True, int)' returns True]
R: ___ [can use: vIsObj = is.na(match(class(vVar), c("numeric", "integer", "character", "logical", "NULL")))] [note: it may be desirable to exclude vectors of size not equal to 1 by testing length()]
Ruby: ___ [can use: vIsObj = !(vVar.is_a?(NilClass) || vVar.is_a?(TrueClass) || vVar.is_a?(FalseClass) || vVar.is_a?(Integer) || vVar.is_a?(Float) || vVar.is_a?(String))]
Rust: ___
Scala: ___ [can use: var vIsObj = !(vVar.isInstanceOf[Int] || vVar.isInstanceOf[Byte] || vVar.isInstanceOf[Short] || vVar.isInstanceOf[Long] || vVar.isInstanceOf[Float] || vVar.isInstanceOf[Double] || vVar.isInstanceOf[Boolean] || vVar.isInstanceOf[Char] || vVar.getClass().getSimpleName().equals("String"))] [WARNING: throws on nulls]
Swift: ___ [can use: vIsObj = !((vVar is String) || (vVar is Int) || (vVar is Float) || (vVar is Double) || (vVar is Bool))]
UFL: Any.IsArray [e.g. for a custom print function (e.g. use string join on 1-dimensional arrays)]
AutoHotkey: vVar is Array
C++: std::is_array<decltype(vVar)>::value [requires: #include <type_traits>]
C#: vVar is Array
Crystal: vVar.is_a?(Array)
Excel: ___
Excel VBA: IsArray(vVar)
Go: ___ [can use: reflect.TypeOf]
Java: ((Object)vVar).getClass().isArray()
JavaScript: Array.isArray(vVar)
Kotlin: vVar::class.java.isArray
PHP: is_array($vVar) [also ('keys consist of consecutive numbers from 0 to count($array)-1'): array_is_list($vVar)]
Python: isinstance(vVar, list)
R: ___ [can use: vIsVec = is.vector(vVar) & !is.list(vVar)] [WARNING: in R, a 'primitive' and a one-item vector (containing a 'primitive') are identical] [note: length(vVar) to get the vector item count, nchar(vVar) to get a string's length] [WARNING: R uses the word 'primitive' regarding function types]
Ruby: vVar.is_a?(Array)
Rust: ___
Scala: vVar.getClass().isArray() [WARNING: throws on nulls]
Swift: vVar is Array<Any>
UFL: Any.CopyRef [create reference][note: object of any type][i.e. multiple variables point to the same object, so 'modifying one modifies all'][see also: Array.Clone/Map.Clone/Object.Clone/Range.Clone/Tuple.Clone]
AutoHotkey: oObjNew := oObj
C++: &oObjNew = oObj [e.g. MyStruct &oObjNew = oObj] [e.g. std::string (&oArrayNew)[] = oArray] [e.g. std::map<std::string,std::string> &oMapNew = oMap] [e.g. auto &oRangeNew = oRange] [e.g. auto &oVecNew = oVec]
C#: oObjNew = oObj
Crystal: oObjNew = oObj
Excel: ___
Excel VBA: Set oObjNew = oObj [note: this fails with Array objects, there is not a standard way to create a reference to an Array object]
Go: oObjNew = oObj
Java: oObjNew = oObj
JavaScript: oObjNew = oObj
Kotlin: oObjNew = oObj
PHP: $oObjNew = $oObj [WARNING: for arrays, this copies (clones) the array, instead, do: $oArrayNew = &$oArray]
Python: oObjNew = oObj
R: ___ [WARNING: 'oObjNew = oObj' copies (clones) an object]
Ruby: oObjNew = oObj
Rust: ___
Scala: oObjNew = oObj
Swift: oObjNew = oObj [WARNING: for value types (e.g. Array/Dictionary/Tuple/Struct/Enum), this copies (clones) the object]
UFL: Any.DelRef [or Any.DeleteRef][delete object reference (and delete object if it's the last reference)][see also: VarDelete][note: object of any type]
AutoHotkey: oObj := unset [note: in AHK v1: 'oObj := ""' and 'oObj := 0' were common]
C++: delete oObj [also: delete[] oObj] [note: 'delete'/'delete[]' must be used for variables created with 'new'] [note: 'free' must be used for variables created with 'malloc']
C#: oObj = null
Crystal: oObj = nil
Excel: ___
Excel VBA: Set oObj = Nothing [note: doesn't work with all types]
Go: oObj = nil
Java: oObj = null
JavaScript: oObj = null [also: oObj = undefined] [also: void operator]
Kotlin: oObj = null
PHP: unset($oObj) [also: $oObj = null] [note: unset() sets contents to null]
Python: del oObj [also: oObj = None]
R: oObj = NULL [also: rm(oObj1, oObj2, oObj3)]
Ruby: oObj = nil
Rust: ___ [can use (if appropriate): drop(oObj)]
Scala: oObj = null
Swift: oObj = nil
Section: Array Methods
UFL: Array.Print [print the values][tested on int/float/string arrays][see also: Array.Join/Array.ToString]
AutoHotkey: ___
C++: for (const auto& vValue : oArray) std::cout << vValue << "," [also (for array on the heap): for (const auto& vValue : std::views::counted(oArray, vSize)) std::cout << vValue << ","] [requires (views::counted): #include <ranges>] [also (for array on the heap): for (const auto& vValue : *(int(*)[vSize])oArray)] [also (for array on the heap): for (const auto& vValue : *(int(*)[vSize])&oArray[0])]
C#: Console.WriteLine("[" + String.Join(",", oArray) + "]") [note: also works with lists]
Crystal: p oArray [note: prints on 1 line, and appends a linefeed] [also: puts oArray.inspect]
Excel: ___
Excel VBA: Debug.Print "[" & Join(oArray, ",") & "]"
Go: fmt.Println(oArray) [requires: import "fmt"]
Java: System.out.println(java.util.Arrays.toString(oArray)) [also: System.out.println(java.util.Arrays.deepToString(oArray))] [note: deepToString() worked on: String[]/int[][]/double[][]/String[][], failed on: int[]/double[]] [also: System.out.println(oList)]
JavaScript: console.log(oArray)
Kotlin: println(oArray.toList())
PHP: var_export($oArray) [also: var_dump($oArray)] [also: print_r($oArray)] [note: var_export/var_dump/print_r all print keys and values]
Python: print(oList)
R: print(oVec)
Ruby: p oArray [note: prints on 1 line, and appends a linefeed] [also: puts oArray.inspect]
Rust: println!("{:?}", oArray)
Scala: println(oArray.mkString(", ")) [also: println(oArray.toList)]
Swift: print(oArray)
UFL: Array.PrintWithIndex [print the key-value pairs][tested on int/float/string arrays][see also: Array.LoopWithIndex/Array.Entries/Array.ToMap/Map.Print/PrintKeyValue]
AutoHotkey: ___
C++: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++) std::cout << i << ":" << oArray[i] << "\n" [also: for (int i=0; i<oVec.size(); i++) std::cout << i << ":" << oVec[i] << "\n"]
C#: Console.WriteLine(String.Join("\n", oArray.Select((v,k)=>$"{k}:{v}"))) [also: Console.WriteLine(String.Join("\n", oArray.Select((v,k)=>String.Join(":",k,v))))] [also: Console.WriteLine(String.Join("\n", oArray.Select((v,k)=>new{k,v})))] [also: Console.WriteLine(String.Join("\n", oArray.Select((v,k)=>new{MyKey=k,MyValue=v})))] [requires (Select): using System.Linq]
Crystal: p Hash.zip((0...oArray.size).to_a, oArray)
Excel: ___
Excel VBA: For i = LBound(oArray) To UBound(oArray): Debug.Print i & ":" & oArray(i): Next [note: using ':' to write multiple code lines on one line]
Go: for vKey, vValue := range oArray { fmt.Printf("%v: %v\n", vKey, vValue) } [note: the Go Playground will auto-format this]
Java: for (int i=0; i<oArray.length; i++) System.out.println(i + ":" + oArray[i])
JavaScript: console.log([...oArray.entries()].join("\n"))
Kotlin: println(oArray.mapIndexed{k,v->k to v!!}.toMap()) [also: println(oArray.mapIndexed{k,v->k to v!!})] [also: println(oArray.mapIndexed{k,v->k to v!!}.joinToString("\n"))] [also: println(oArray.withIndex().toList())]
PHP: var_export($oArray) [also: var_dump($oArray)] [also: print_r($oArray)]
Python: print({k:v for k,v in enumerate(oList)}) [also: print(list(enumerate(oList)))] [also: print("\n".join(map(str, enumerate(oList))))] [also: print("\n".join(map(lambda v : str(v[0])+":"+str(v[1]), enumerate(oList))))] [also: print("\n".join([str(k)+":"+str(v) for k,v in enumerate(oList)]))]
R: for(i in 1:length(oVec)) {print(paste(i, oVec[i], sep=": "))}
Ruby: p oArray.map.with_index{|v,k| [k,v]}.to_h [also: p ((0...oArray.length).zip oArray).to_h] [also: p Hash[(0...oArray.length).zip oArray]]
Rust: println!("{:?}", oArray.iter().enumerate().collect::<Vec<_>>()) [also: println!("{}", oArray.iter().enumerate().map(|(k,v)| format!("{}:{}", k, v)).collect::<Vec<_>>().join("\n"))]
Scala: println(oArray.zipWithIndex.mkString(", ")) [also: println(oArray.zipWithIndex.toList)] [also: for((vValue,vKey) <- oArray.view.zipWithIndex) println((vKey,vValue))]
Swift: print(oArray.enumerated().map{($0,$1)}) [also: print(oArray.enumerated().map{String($0)+":"+String($1)}.joined(separator:"\n"))]
UFL: Array.LoopValue [loop through the items of an array, get values one-by-one]
AutoHotkey: for _, vValue in oArray [also (AHK v2 onwards): for vValue in oArray]
C++: for (const auto& vValue : oArray) [also: for (const auto& vValue : oVec)]
C#: foreach (var vValue in oArray)
Crystal: oArray.each do |vValue| [afterwards: end]
Excel: ___
Excel VBA: ___ [can use: For i = LBound(oArray) To UBound(oArray)] [note: vValue = oArray(i)] [also (for collections): For Each vValue In oColl] [afterwards (for both): Next]
Go: for _, vValue := range oArray
Java: for (var vValue : oArray)
JavaScript: for (const vValue of oArray) [also (ES6): oArray.forEach(function(vValue)...] [also: for (var i=0; i<oArray.length; i++)]
Kotlin: for (vValue in oArray)
PHP: foreach ($oArray as $vValue)
Python: for vValue in oList:
R: for(vValue in oVec) [also: for(vValue in oList)]
Ruby: for vValue in oArray [afterwards: end]
Rust: for vValue in oArray
Scala: for(vValue <- oArray)
Swift: for vValue in oArray
UFL: Array.LoopWithIndex [loop through the items of an array, get key-value pairs one-by-one]
AutoHotkey: for vKey, vValue in oArray
C++: ___ [can use: for (const auto& vValue : oArray)] [note (won't work on all object types): vKey = &vValue-&oArray[0]] [also: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++)] [also: for (int i=0; i<oVec.size(); i++)]
C#: foreach (var e in oArray.Select((v,k)=>new{k,v})) [also: foreach (var oEntry in oArray.Select((v,k)=>new{MyKey=k,MyValue=v}))] [e.g. e.k, e.v] [e.g. oEntry.MyKey, oEntry.MyValue] [requires: using System.Linq]
Crystal: oArray.each_with_index do |vValue,vKey| [WARNING: order is value then key] [afterwards: end]
Excel: ___
Excel VBA: ___ [can use: For i = LBound(oArray) To UBound(oArray)] [note: vValue = oArray(i)] [afterwards: Next]
Go: for vKey, vValue := range oArray
Java: ___ [can use: for (int i=0; i<oArray.length; i++)] [note: vValue = oArray[i]]
JavaScript: for (const [vKey, vValue] of oArray.entries()) [also (ES6): oArray.forEach(function(vValue, vKey)...] [also (unspecified order): for (var vKey in oArray)]
Kotlin: for ((vKey, vValue) in oArray.withIndex())
PHP: foreach ($oArray as $vKey=>$vValue)
Python: for vKey, vValue in enumerate(oList):
R: for(i in 1:length(oVec)) [note: vValue = oVec[i]] [also: for(i in seq_along(oVec))]
Ruby: for vValue, vKey in oArray.each_with_index [WARNING: order is value then key] [afterwards: end]
Rust: for (vKey, vValue) in oArray.iter().enumerate()
Scala: for((vValue,vKey) <- oArray.view.zipWithIndex)
Swift: for (vKey, vValue) in oArray.enumerated()
UFL: Array.ForEach [or Array.LoopForEach][call a function once for each item of an array][see also: Array.Map/Array.LoopValue]
AutoHotkey: ___
C++: std::for_each(std::begin(oArray), std::end(oArray), oFunc) [note: Func receives value] [requires (for_each): #include <algorithm>]
C#: ___ [can use: foreach (var v in oArray) oFunc(v)]
Crystal: oArray.each{|v| oFunc.call(v)}
Excel: ___
Excel VBA: ___
Go: ___
Java: Arrays.stream(oArray).forEach(oFunc) [note: Func receives value] [requires: import java.util.*]
JavaScript: oArray.forEach(oFunc) [also: oArray.forEach(v=>oFunc(v))] [note: Func receives value/key/object]
Kotlin: oArray.forEach(oFunc) [also: oArray.forEach{oFunc(it)}] [note: Func receives value]
PHP: ___ [can use: foreach ($oArray as $v) $oFunc($v)]
Python: ___ [can use: for v in oList: oFunc(v)]
R: ___ [can use: for(v in oVec) oFunc(v)]
Ruby: oArray.each{|v| oFunc.call(v)}
Rust: oArray.iter().for_each(|v| oFunc(v))
Scala: oArray.foreach(oFunc) [also: oArray.foreach(oFunc(_))] [also: oArray.foreach(v=>oFunc(v))] [note: Func receives value]
Swift: oArray.forEach(oFunc) [also: oArray.forEach{oFunc($0)}] [note: Func receives value]
UFL: Array.ForEachWithIndex [or Array.LoopForEachWithIndex][call a function once for each item of an array][see also: Array.Map/Array.Entries/Array.LoopWithIndex]
AutoHotkey: ___
C++: ___ [can use: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++) oFunc(i, oArray[i])] [also: for (int i=0; i<oVec.size(); i++) oFunc(i, oVec[i])]
C#: ___ [can use: foreach (var e in oArray.Select((v,k)=>new{k,v})) oFunc(e.k,e.v)] [requires (Select): using System.Linq]
Crystal: oArray.each_with_index{|v,k| oFunc.call(k,v)}
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use: IntStream.range(0, oArray.length).forEach(i->oFunc.accept(i,oArray[i]))] [requires: import java.util.stream.*]
JavaScript: oArray.forEach(oFunc) [also: oArray.forEach((v,k)=>oFunc(k,v))] [note: Func receives value/key/object]
Kotlin: oArray.forEachIndexed(oFunc) [also: oArray.forEachIndexed{k,v->oFunc(k,v)}] [note: Func receives key/value]
PHP: ___ [can use: foreach ($oArray as $k=>$v) $oFunc($k,$v)]
Python: ___ [can use: for k,v in enumerate(oList): oFunc(k,v)]
R: ___ [can use: for(k in 1:length(oVec)) oFunc(k,oVec[k])]
Ruby: oArray.each_with_index{|v,k| oFunc.call(k,v)}
Rust: oArray.iter().enumerate().for_each(|(k,v)| oFunc(k,*v))
Scala: oArray.view.zipWithIndex.foreach((v,k)=>oFunc(k,v)) [note: Func receives value/key]
Swift: oArray.enumerated().forEach(oFunc) [also: oArray.enumerated().forEach{oFunc($0,$1)}] [note: Func receives key/value]
UFL: Array.NewEmpty [or Array.NewBasic][create an empty array]
AutoHotkey: oArray := [] [type: Array] [note: 1-based]
C++: int oArray[] = {} [type: e.g. A0_i / A0_d / (mangled) (int/double/std::string arrays respectively)] [also: std::vector<int> oVec]
C#: int[] oArray = {} [type: e.g. Int32[] / Double[] / String[] (int/double/string arrays respectively)] [also (C# 12 onwards): int[] oArray = []] [also: var oList = new List<int>()] [requires (List): using System.Collections.Generic]
Crystal: oArray = [] of Int32 [type: Array(Int32) / Array(Float64) / Array(String)]
Excel: ___
Excel VBA: oArray = Array() [type: Variant()] [note: 0-based by default, can specify the start index] [note: an alternative class: Set oArray = CreateObject("System.Collections.ArrayList")]
Go: oArray := [0]int{} [type: e.g. [0]int / [0]float64 / [0]string] [note: to omit the count (to let the compiler count the members), use '...', e.g. oArray := [...]int{}] [WARNING: omitting the count, i.e. '[]', creates a slice, not an array]
Java: int[] oArray = {} [type: e.g. int[] / double[] / String[] (int/double/string arrays respectively)] [also: var oList = new ArrayList<Integer>()]
JavaScript: oArray = [] [type: Array]
Kotlin: oArray = arrayOf<Int>() [type: Array] [also: oArray: Array<Int> = arrayOf()]
PHP: $oArray = [] [type: array] [also: array()] [note: an associative array that also has linear array functionality] [note: 0-based by default, can specify the start index]
Python: oList = [] [type: list]
R: oVec = numeric(0) [e.g. type: double (class: numeric) / character] [also (1-item vec to 0-item vec): oVec = c(0)[-1]] [note: 1-based] [WARNING: for vectors, typeof/class report the type of the item]
Ruby: oArray = [] [type: Array]
Rust: oArray: [i32; 0] = [] [type: '[i32; 0]'] [also: let mut oVec: Vec<i32> = vec![]]
Scala: oArray = Array[Int]() [type: e.g. int[] / double[] / String[] (int/double/string arrays respectively)] [also: var oList = List[Int]()] [type (empty list): Nil$] [type (non-empty list): $colon$colon]
Swift: oArray = [Int]() [type: e.g. Array<Int> / Array<Double> / Array<String> (Int/Double/String arrays respectively)]
UFL: (Array.NewIntDemo) [create an array containing 1, 2, 3]
AutoHotkey: oArray := [1, 2, 3]
C++: int oArray[] = {1, 2, 3} [also: std::vector<int> oVec = {1, 2, 3}]
C#: int[] oArray = {1, 2, 3} [also: var oList = new List<int>{1, 2, 3}] [requires (List): using System.Collections.Generic]
Crystal: oArray = [1, 2, 3]
Excel: ___
Excel VBA: oArray = Array(1, 2, 3)
Go: oArray := [...]int{1, 2, 3} [also: oSlice := []int{1, 2, 3}] [also: oArray := [3]int{1, 2, 3}]
Java: int[] oArray = {1, 2, 3} [also (fixed size): List<Integer> oList = Arrays.asList(1, 2, 3)] [also (read-only): var oList = List.of(1, 2, 3)] [note: see 'Array.ToList' to create a mutable list from an array]
JavaScript: oArray = [1, 2, 3]
Kotlin: oArray = arrayOf(1, 2, 3)
PHP: $oArray = [1, 2, 3]
Python: oList = [1, 2, 3]
R: oVec = c(1, 2, 3) [WARNING: these are equivalent: oVec = 1; oVec = c(1)] [WARNING: these are equivalent: oVecNew = as.character(oVec); oVecNew = mapply(\(v) as.character(v), oVec)]
Ruby: oArray = [1, 2, 3]
Rust: oArray = [1, 2, 3]
Scala: oArray = Array(1, 2, 3) [also: var oList = List(1, 2, 3)]
Swift: oArray = [1, 2, 3] [e.g. empty array: oArray = [Int]()]
UFL: (Array.NewFloatDemo) [or Array.NewDoubleDemo][create an array containing 1.1, 2.2, 3.3]
AutoHotkey: oArray := [1.1, 2.2, 3.3]
C++: double oArray[] = {1.1, 2.2, 3.3} [also: std::vector<double> oVec = {1.1, 2.2, 3.3}]
C#: double[] oArray = {1.1, 2.2, 3.3} [also: var oList = new List<double>{1.1, 2.2, 3.3}] [note: 'double' is preferred, 'Double' also works] [requires (List): using System.Collections.Generic]
Crystal: oArray = [1.1, 2.2, 3.3]
Excel: ___
Excel VBA: oArray = Array(1.1, 2.2, 3.3)
Go: oArray := [...]float64{1.1, 2.2, 3.3} [also: oSlice := []float64{1.1, 2.2, 3.3}] [also: oArray := [3]float64{1.1, 2.2, 3.3}]
Java: double[] oArray = {1.1, 2.2, 3.3} [also (fixed size): List<Double> oList = Arrays.asList(1.1, 2.2, 3.3)] [also (read-only): var oList = List.of(1.1, 2.2, 3.3)] [note: see 'Array.ToList' to create a mutable list from an array]
JavaScript: oArray = [1.1, 2.2, 3.3]
Kotlin: oArray = arrayOf(1.1, 2.2, 3.3)
PHP: $oArray = [1.1, 2.2, 3.3]
Python: oList = [1.1, 2.2, 3.3]
R: oVec = c(1.1, 2.2, 3.3)
Ruby: oArray = [1.1, 2.2, 3.3]
Rust: oArray = [1.1, 2.2, 3.3]
Scala: oArray = Array(1.1, 2.2, 3.3) [also: var oList = List(1.1, 2.2, 3.3)]
Swift: oArray = [1.1, 2.2, 3.3] [e.g. empty array: oArray = [Double]()]
UFL: (Array.NewFloatExDemo) [or Array.NewDoubleExDemo][create an array containing floats e.g. -Inf/Inf/NaN][see also: NaN/Infinity]
AutoHotkey: oArray := [-123.456, -0.0, 0.0, 123.456, -Abs(Ln(0)), Abs(Ln(0)), Abs(Ln(0)/Ln(0))]
C++: double oArray[] = {-123.456, -0.0, 0.0, 123.456, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()}
C#: double[] oArray = {-123.456, -0.0, 0.0, 123.456, Double.NegativeInfinity, Double.PositiveInfinity, Double.NaN}
Crystal: oArray = [-123.456, -0.0, 0.0, 123.456, -Float64::INFINITY, Float64::INFINITY, Float64::NAN]
Excel: ___
Excel VBA: oArray = Array(-123.456, -0#, 0#, 123.456, vNInf, vInf, vNaN) [note: need to define NInf/Inf/NaN elsewhere]
Go: oArray := [...]float64{-123.456, math.Copysign(0.0, -1), 0.0, 123.456, math.Inf(-1), math.Inf(1), math.NaN()}
Java: double[] oArray = {-123.456, -0.0, 0.0, 123.456, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.NaN}
JavaScript: oArray = [-123.456, -0.0, 0.0, 123.456, -Infinity, Infinity, NaN]
Kotlin: oArray = arrayOf(-123.456, -0.0, 0.0, 123.456, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.NaN)
PHP: $oArray = [-123.456, -0.0, 0.0, 123.456, -INF, INF, NAN]
Python: oList = [-123.456, -0.0, 0.0, 123.456, float("-inf"), float("inf"), float("nan")]
R: oVec = c(-123.456, -0.0, 0.0, 123.456, -Inf, Inf, NaN)
Ruby: oArray = [-123.456, -0.0, 0.0, 123.456, -Float::INFINITY, Float::INFINITY, Float::NAN]
Rust: oArray = [-123.456, -0.0, 0.0, 123.456, -std::f64::INFINITY, std::f64::INFINITY, std::f64::NAN]
Scala: oArray = Array(-123.456, -0.0, 0.0, 123.456, Double.NegativeInfinity, Double.PositiveInfinity, Double.NaN)
Swift: oArray = [-123.456, -0.0, 0.0, 123.456, -Double.infinity, Double.infinity, Double.nan]
UFL: (Array.OverwriteIntDemo) [or Array.NewOverwriteIntDemo][overwrite an existing array (redefine/reassign)][note: the syntax is often identical to creating an array][replace an array with a new array][this syntax can often be used to temporarily create an array, to print it]
AutoHotkey: oArray := [1, 2, 3]
C++: ___ [can use: oVec = {1, 2, 3}] [also: oVec = std::vector<int>{1, 2, 3}]
C#: oArray = [1, 2, 3] [also: oArray = (int[])[1, 2, 3]] [also: oArray = new int[]{1, 2, 3}] [also: oList = [1, 2, 3]] [also: oList = (List<int>)[1, 2, 3]] [also: oList = new List<int>{1, 2, 3}]
Crystal: oArray = [1, 2, 3]
Excel: ___
Excel VBA: oArray = Array(1, 2, 3)
Go: oArray = [...]int{1, 2, 3} [also: oSlice = []int{1, 2, 3}] [note: can only overwrite an existing array with an array of the same size]
Java: oArray = new int[]{1, 2, 3} [also: oList = Arrays.asList(1, 2, 3)] [also: oList = List.of(1, 2, 3)]
JavaScript: oArray = [1, 2, 3]
Kotlin: oArray = arrayOf(1, 2, 3)
PHP: $oArray = [1, 2, 3]
Python: oList = [1, 2, 3]
R: oVec = c(1, 2, 3)
Ruby: oArray = [1, 2, 3]
Rust: let oArray = [1, 2, 3]
Scala: oArray = Array(1, 2, 3) [also: oList = List(1, 2, 3)]
Swift: oArray = [1, 2, 3]
UFL: (Array.NewStrDemo) [create an array containing a, b, c]
AutoHotkey: oArray := ["a", "b", "c"]
C++: std::string oArray[] = {"a", "b", "c"} [also: std::vector<std::string> oVec = {"a", "b", "c"}]
C#: string[] oArray = {"a", "b", "c"} [note: 'String[]' also works] [also: var oList = new List<string>{"a", "b", "c"}] [requires (List): using System.Collections.Generic]
Crystal: oArray = ["a", "b", "c"]
Excel: ___
Excel VBA: oArray = Array("a", "b", "c")
Go: oArray := [...]string{"a", "b", "c"} [also: oSlice := []string{"a", "b", "c"}] [also: oArray := [3]string{"a", "b", "c"}]
Java: String[] oArray = {"a", "b", "c"} [note: 'string[]' doesn't work] [also (fixed size): List<String> oList = Arrays.asList("a", "b", "c")] [also (read-only): var oList = List.of("a", "b", "c")] [note: see 'Array.ToList' to create a mutable list from an array]
JavaScript: oArray = ["a", "b", "c"]
Kotlin: oArray = arrayOf("a", "b", "c")
PHP: $oArray = ["a", "b", "c"]
Python: oList = ["a", "b", "c"]
R: oVec = c("a", "b", "c")
Ruby: oArray = ["a", "b", "c"]
Rust: oArray = ["a", "b", "c"]
Scala: oArray = Array("a", "b", "c") [also: var oList = List("a", "b", "c")]
Swift: oArray = ["a", "b", "c"] [e.g. empty array: oArray = [String]()]
UFL: (Array.NewEntriesStrDemo) [or Array.NewArrayOfArraysStrDemo/Entries.NewStrDemo][array of arrays, e.g. entries (key-value pairs)]
AutoHotkey: oEntries := [["k1","v1"], ["k2","v2"], ["k3","v3"]]
C++: std::string oEntries[][2] = {{"k1","v1"}, {"k2","v2"}, {"k3","v3"}} [also: std::vector<std::vector<std::string>> oEntries = {{"k1","v1"}, {"k2","v2"}, {"k3","v3"}}]
C#: string[][] oEntries = {new[]{"k1","v1"}, new[]{"k2","v2"}, new[]{"k3","v3"}}
Crystal: oEntries = [["k1","v1"], ["k2","v2"], ["k3","v3"]]
Excel: ___
Excel VBA: oEntries = Array(Array("k1", "v1"), Array("k2", "v2"), Array("k3", "v3"))
Go: oEntries := [...][2]string{{"k1", "v1"}, {"k2", "v2"}, {"k3", "v3"}} [also (a slice of slices): oEntries := [][]string{{"k1", "v1"}, {"k2", "v2"}, {"k3", "v3"}}]
Java: String[][] oEntries = {{"k1","v1"}, {"k2","v2"}, {"k3","v3"}}
JavaScript: oEntries = [["k1","v1"], ["k2","v2"], ["k3","v3"]]
Kotlin: oEntries = arrayOf(arrayOf("k1","v1"), arrayOf("k2","v2"), arrayOf("k3","v3"))
PHP: $oEntries = [["k1","v1"], ["k2","v2"], ["k3","v3"]]
Python: oEntries = [["k1","v1"], ["k2","v2"], ["k3","v3"]]
R: oEntries = list(list("k1","v1"), list("k2","v2"), list("k3","v3")) [e.g. vValue = unlist(oEntries[1])[1]]
Ruby: oEntries = [["k1","v1"], ["k2","v2"], ["k3","v3"]]
Rust: oEntries = [["k1","v1"], ["k2","v2"], ["k3","v3"]]
Scala: oEntries = Array(("k1","v1"), ("k2","v2"), ("k3","v3")) [note: array of tuples] [also (2D array): var oEntries = Array(Array("k1","v1"), Array("k2","v2"), Array("k3","v3"))]
Swift: oEntries = [["k1","v1"], ["k2","v2"], ["k3","v3"]]
UFL: (Array.NewMultiTypeDemo) [create an array containing values of multiple types for testing]
AutoHotkey: oArray := ["abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, true, false, -Abs(Ln(0)), Abs(Ln(0)), Abs(Ln(0)/Ln(0))] [note: false and 0 are identical]
C++: ___
C#: object[] oArray = {"abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, true, false, Double.NegativeInfinity, Double.PositiveInfinity, Double.NaN}
Crystal: oArray = ["abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, true, false, -Float64::INFINITY, Float64::INFINITY, Float64::NAN]
Excel: ___
Excel VBA: oArray = Array("abc", "", -123, 0, 123, -123.456, -0#, 0#, 123.456, True, False, vNInf, vInf, vNaN) [note: need to define NInf/Inf/NaN elsewhere]
Go: oArray := [...]interface{}{"abc", "", -123, 0, 123, -123.456, math.Copysign(0.0, -1), 0.0, 123.456, true, false, math.Inf(-1), math.Inf(1), math.NaN()} [note: use '[]' instead of '[...]' for a slice]
Java: Object[] oArray = {"abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, true, false, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.NaN}
JavaScript: oArray = ["abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, true, false, -Infinity, Infinity, NaN]
Kotlin: oArray = arrayOf("abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, true, false, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, Double.NaN)
PHP: $oArray = ["abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, true, false, -INF, INF, NAN]
Python: oList = ["abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, True, False, float("-inf"), float("inf"), float("nan")]
R: ___ [can use: oList = list("abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, TRUE, FALSE, -Inf, Inf, NaN)] [note: vectors coerce values to one type (e.g. character (string)/numeric)] [also: as.integer(vNum)]
Ruby: oArray = ["abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, true, false, -Float::INFINITY, Float::INFINITY, Float::NAN]
Rust: ___ [note: workaround an array/vector of enums]
Scala: oArray = Array("abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, true, false, Double.NegativeInfinity, Double.PositiveInfinity, Double.NaN)
Swift: oArray = ["abc", "", -123, 0, 123, -123.456, -0.0, 0.0, 123.456, true, false, -Double.infinity, Double.infinity, Double.nan] as [Any]
UFL: (Array.NewMultiTypeFalsyDemo) [create an array containing values of multiple types, with falsy values][note: other values to consider: NaN, null, empty objects, some object types]
AutoHotkey: oArray := ["", 0, 0.0, -0.0, false] [note: false and 0 are identical]
C++: ___
C#: object[] oArray = {"", 0, 0.0, -0.0, false}
Crystal: oArray = ["", 0, 0.0, -0.0, false]
Excel: ___
Excel VBA: oArray = Array("", 0, -0#, 0#, False)
Go: oArray := [...]interface{}{"", 0, 0.0, math.Copysign(0.0, -1), false} [note: use '[]' instead of '[...]' for a slice]
Java: Object[] oArray = {"", 0, 0.0, -0.0, false}
JavaScript: oArray = ["", 0, 0.0, -0.0, false]
Kotlin: oArray = arrayOf("", 0, 0.0, -0.0, false)
PHP: $oArray = ["", 0, 0.0, -0.0, false]
Python: oList = ["", 0, 0.0, -0.0, False]
R: ___ [can use: oList = list("", 0, 0.0, -0.0, FALSE)] [note: vectors coerce values to one type (e.g. character (string)/numeric)] [also: as.integer(0)]
Ruby: oArray = ["", 0, 0.0, -0.0, false]
Rust: ___ [note: workaround an array/vector of enums]
Scala: oArray = Array("", 0, 0.0, -0.0, false)
Swift: oArray = ["", 0, 0.0, -0.0, false] as [Any]
UFL: (Array.NewSizeDemo) [create an array of size n, the values don't matter][see also: Array.Rept/Range.ToArray]
AutoHotkey: (oArray := []).Length := vCount [note: 'no value'-initialised] [also (space-initialised, i.e. 1-char string, Chr(32)): StrSplit(Format("{:" vCount "}", ""))]
C++: int* oArray = new int[vCount] [note: zero-initialised] [also ('random'-value-initialised, replace '123' with the necessary size): int oArray[123]] [also (zero-initialised): int oArray[123] = {}] [also (zero-initialised): std::vector<int> oVec(vCount)]
C#: int[] oArray = new int[vCount] [also: var oList = Enumerable.Repeat(0, vCount).ToList()] [note: both zero-initialised] [requires (Enumerable.Repeat): using System.Linq]
Crystal: oArray = Array.new(vCount, 0)
Excel: ___
Excel VBA: ReDim oArray(0 To vCount - 1) [note: empty-initialised] [note (zero-initialised): ReDim oArray(0 To vCount - 1) As Integer]
Go: oSlice := make([]int, vCount) [also (cannot set array size dynamically, replace '123' as appropriate): oArray := [123]int{}]
Java: int[] oArray = new int[vCount] [note: zero-initialised]
JavaScript: oArray = Array(vCount) [note: empty-initialised (elided)] [also (zero-initialised): oArray = Array(vCount).fill(0)]
Kotlin: oArray = IntArray(vCount) [note: zero-initialised]
PHP: $oArray = range(0, $vCount-1) [also (zero-initialised): $oArray = array_fill(0, $vCount, 0)]
Python: oList = [0] * vCount [note: zero-initialised]
R: oVec = 1:vCount [note: the R range is a vector]
Ruby: oArray = Array.new(vCount)
Rust: oArray = [0; vCount] [beforehand: const vCount: usize = 10] [WARNING: can't set count at runtime]
Scala: oArray = Array.fill(vCount)(0)
Swift: oArray = Array(repeating:0, count:vCount) [note: zero-initialised]
UFL: Array.Rept [or Array.Repeat][create an array of the same value repeated n times][see also: Array.Fill]
AutoHotkey: ___
C++: std::fill(oArray, oArray+vCount, vValue) [beforehand: int* oArray = new int[vCount]] [also (array): std::fill(std::begin(oArray), std::end(oArray), vValue)] [also (vector): std::fill(oVec.begin(), oVec.end(), vValue)] [beforehand (vector): std::vector<int> oVec(vCount)] [requires (fill): #include <algorithm>]
C#: Array.Fill(oArray, vValue) [beforehand: int[] oArray = new int[vCount]] [also (requires: using System.Linq): int[] oArray = Enumerable.Repeat(vValue, vCount).ToArray()]
Crystal: oArray = Array.new(vCount, vValue)
Excel: ___
Excel VBA: ___
Go: ___
Java: int[] oArray = Collections.nCopies(vCount, vValue).stream().mapToInt(v->v).toArray() [also: String[] oArray = Collections.nCopies(vCount, vValue).toArray(new String[0])] [requires: import java.util.*] [also: java.util.Arrays.fill(oArray, vValue)] [beforehand (fill): int[] oArray = new int[vCount]]
JavaScript: oArray = Array(vCount).fill(vValue) [also (ES5): Array.apply(null, Array(vCount)).map(function(){return vValue})]
Kotlin: oArray = Array(vCount){vValue} [also: oArray = IntArray(vCount){vValue}] [also: oList = List(vCount){vValue}]
PHP: $oArray = array_fill($vIndex, $vCount, $vValue) [e.g. $vIndex = 0 for a 0-based array] [also: $oArray = array_pad([], $vCount, $vValue)]
Python: oList = [vValue] * vCount
R: oVec = rep(vValue, vCount)
Ruby: oArray = Array.new(vCount, vValue)
Rust: oVec = vec![vValue; vCount] [also: oVec = (0..vCount).map(|_| vValue).collect::<Vec<_>>()] [also (overwrite existing values): oVec.fill(vValue)]
Scala: oArray = Array.fill(vCount)(vValue)
Swift: oArray = Array(repeating:vValue, count:vCount)
UFL: Array.ReptMult [e.g. [1,2,3] to [1,2,3,1,2,3,1,2,3]][create an array of the same value(s) repeated n times]
AutoHotkey: ___
C++: ___
C#: oArrayNew = Enumerable.Repeat(oArray, vCount).SelectMany(v=>v).ToArray() [requires: using System.Linq]
Crystal: oArrayNew = oArray * vCount [also: oArrayNew = Array.new(vCount, oArray).flatten]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use: int[] oArrayNew = Stream.iterate(oArray, v->v).flatMapToInt(IntStream::of).limit(oArray.length*vCount).toArray()] [also: String[] oArrayNew = Stream.iterate(oArray, v->v).flatMap(v->Stream.of(oArray)).limit(oArray.length*vCount).toArray(String[]::new)] [also: int[] oArrayNew = Stream.of(Collections.nCopies(vCount, oArray).stream().toArray(int[][]::new)).flatMapToInt(IntStream::of).toArray()] [also: String[] oArrayNew = Stream.of(Collections.nCopies(vCount, oArray).stream().toArray(String[][]::new)).flatMap(Stream::of).toArray(String[]::new)]
JavaScript: oArrayNew = Array(vCount).fill(oArray).flat()
Kotlin: oArrayNew = Array(vCount){oArray}.flatten().toTypedArray() [also: oListNew = List(vCount){oList}.flatten()] [also: oArrayNew = generateSequence{oArray.asIterable()}.flatten().take(oArray.size*vCount).toList().toTypedArray()]
PHP: $oArrayNew = array_merge(...array_fill(0, $vCount, $oArray))
Python: oListNew = oList * vCount
R: oVecNew = rep(oVec, vCount)
Ruby: oArrayNew = oArray * vCount [also: oArrayNew = Array.new(vCount, oArray).flatten]
Rust: oVecNew = oArray.iter().cycle().take(oVec.len() * vCount).collect::<Vec<_>>() [note: also works with vectors]
Scala: ___ [can use: oArrayNew = Array.fill(vCount)(oArray).flatten]
Swift: oArrayNew = Array(repeating:oArray, count:vCount).flatMap{$0}
UFL: Array.ReptEach [e.g. [1,2,3] to [1,1,1,2,2,2,3,3,3]][repeat each element n times]
AutoHotkey: ___
C++: ___
C#: oArrayNew = oArray.SelectMany(v=>Enumerable.Repeat(v, vCount)).ToArray() [requires: using System.Linq]
Crystal: oArrayNew = oArray.flat_map{|v| Array.new(vCount, v)}
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use: int[] oArrayNew = Arrays.stream(oArray).mapToObj(v->Collections.nCopies(vCount, v).stream().mapToInt(v2->v2).toArray()).flatMapToInt(IntStream::of).toArray()] [also: String[] oArrayNew = Arrays.stream(oArray).map(v->Collections.nCopies(vCount, v).stream().toArray(String[]::new)).flatMap(Stream::of).toArray(String[]::new)]
JavaScript: oArrayNew = oArray.flatMap(v=>Array(vCount).fill(v))
Kotlin: oArrayNew = oArray.flatMap{v->List(vCount){v}}.toTypedArray() [also: oArrayNew = oArray.flatMap{v->Array(vCount){v}.toList()}.toTypedArray()]
PHP: $oArrayNew = array_merge(...array_map(fn($v)=>array_fill(0, $vCount, $v), $oArray))
Python: oListNew = [v for v in oList for i in range(vCount)]
R: oVecNew = rep(oVec, each=vCount)
Ruby: oArrayNew = oArray.flat_map{|v| Array.new(vCount, v)}
Rust: oVecNew = oArray.iter().flat_map(|v| std::iter::repeat(v).take(vCount)).collect::<Vec<_>>() [note: also works with vectors]
Scala: ___ [can use: oArrayNew = oArray.flatMap(Array.fill(vCount)(_))]
Swift: oArrayNew = oArray.flatMap{Array(repeating:$0, count:vCount)}
UFL: (Array.ReptEach1ToNDemo) [e.g. max=4, count=3: [1,1,1,2,2,2,3,3,3,4,4,4]]
AutoHotkey: ___
C++: ___
C#: oArray = Enumerable.Range(1, vMax).SelectMany(v=>Enumerable.Repeat(v, vCount)).ToArray() [requires: using System.Linq]
Crystal: oArray = (1..vMax).flat_map{|v| Array.new(vCount, v)}
Excel: ___
Excel VBA: ___
Go: ___
Java: int[] oArrayNew = IntStream.rangeClosed(1, vMax).mapToObj(v->Collections.nCopies(vCount, v).stream().mapToInt(v2->v2).toArray()).flatMapToInt(IntStream::of).toArray()
JavaScript: oArray = Array(vMax).fill().flatMap((v,k)=>Array(vCount).fill(k+1))
Kotlin: oArray = (1..vMax).flatMap{v->List(vCount){v}}.toTypedArray() [also: oArray = (1..vMax).flatMap{v->Array(vCount){v}.toList()}.toTypedArray()]
PHP: $oArray = array_merge(...array_map(fn($v)=>array_fill(0, $vCount, $v), range(1, $vMax)))
Python: oList = [v+1 for v in range(vMax) for i in range(vCount)]
R: oVec = rep(1:vMax, each=vCount) [also: oVec = ceiling((1:(vMax*vCount))/vCount)]
Ruby: oArray = (1..vMax).flat_map{|v| Array.new(vCount, v)}
Rust: oVec = (1..=vMax).collect::<Vec<_>>().into_iter().flat_map(|v| std::iter::repeat(v).take(vCount)).collect::<Vec<_>>()
Scala: oArrayNew = Range.inclusive(1, vMax).flatMap(Array.fill(vCount)(_)).toArray
Swift: oArray = (1...vMax).flatMap{Array(repeating:$0, count:vCount)}
UFL: (Array.Keys) [often equivalent to range to array][see also: Range.ToArray]
AutoHotkey: oKeys := [oArray.__Enum(2).Bind(,&_)*]
C++: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++) oKeys.push_back(i) [beforehand: std::vector<int> oKeys]
C#: ___ [can use: var oKeys = Enumerable.Range(0, oArray.Length).ToArray()]
Crystal: ___ [can use: (0...oArray.size).to_a]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use: var oKeys = IntStream.range(0, oArray.length).toArray()]
JavaScript: oKeys = [...oArray.keys()] [also (returns an iterator): oKeys = oArray.keys()]
Kotlin: oKeys = oArray.mapIndexed{k,_->k}.toTypedArray() [also: oKeys = (0..<oArray.count()).toList().toTypedArray()]
PHP: $oKeys = array_keys($oArray)
Python: ___ [can use: oKeys = list(range(len(oList)))]
R: ___ [can use: oKeys = 1:length(oVec)]
Ruby: ___ [can use: (0...oArray.length).to_a]
Rust: ___ [can use: oKeys = (0..oArray.len()).collect::<Vec<_>>()]
Scala: ___ [can use: oKeys = Range(0, oArray.length).toArray]
Swift: oKeys = oArray.enumerated().map{$0.0} [note: failed with $0]
UFL: (Array.Values) [often equivalent to copying an array][see also: Array.Clone]
AutoHotkey: oValues := [oArray*] [also: oValues := oArray.Clone()]
C++: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++) oValues.push_back(oArray[i]) [beforehand: std::vector<std::string> oValues]
C#: ___ [can use: var oValues = oArray.Clone() as string[]] [note: replace 'string[]' with the appropriate type]
Crystal: ___ [can use (clone array): oValues = oArray.clone] [also: oValues = oArray.dup]
Excel: ___
Excel VBA: ___ [can use (clone array): oValues = oArray]
Go: ___ [can use (clone array): oValues := oArray]
Java: ___ [can use: var oValues = oArray.clone()]
JavaScript: oValues = [...oArray.values()] [also (returns an iterator): oValues = oArray.values()] [also: oValues = oArray.slice()]
Kotlin: ___ [can use: oValues = oArray.copyOf()]
PHP: $oValues = array_values($oArray) [also (clone array): $oValues = $oArray]
Python: ___ [can use: oValues = oList.copy()]
R: ___ [can use (clone vector): oValues = oVec]
Ruby: ___ [can use (clone array): oValues = oArray.clone] [also: oValues = oArray.dup]
Rust: ___ [can use: oValues = oArray.clone()]
Scala: ___ [can use: oValues = oArray.clone]
Swift: oValues = oArray.map{$0} [also (clone array): oValues = oArray]
UFL: (Array.Entries) [or Array.ToEntries][array to entries (key-value pairs)]
AutoHotkey: ___
C++: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++) oEntries.push_back(std::make_pair(i, oArray[i])) [beforehand: std::vector<std::pair<int,std::string>> oEntries]
C#: Tuple<int,string>[] oEntries = oArray.Select((v,k)=>new Tuple<int,string>(k,v)).ToArray() [also: KeyValuePair<int,string>[] oEntries = oArray.Select((v,k)=>new KeyValuePair<int,string>(k,v)).ToArray()] [also: string[][] oEntries = oArray.Select((v,k)=>new[]{k.ToString(),v}).ToArray()]
Crystal: oEntries = oArray.each_with_index.map{|v,k| {k,v}}.to_a
Excel: ___
Excel VBA: ___
Go: ___
Java: for (int i=0; i<oArray.length; i++) oEntries[i] = Map.entry(i, oArray[i]) [beforehand: Map.Entry<Integer,String>[] oEntries = new Map.Entry[oArray.length]] [also (indexes as strings): for (int i=0; i<oArray.length; i++) oEntries[i] = new String[]{"" + i, oArray[i]}] [beforehand (indexes as strings): String[][] oEntries = new String[oArray.length][2]] [also (int[]/String[]): oArrayNew = IntStream.range(0, oArray.length).mapToObj(i->Map.entry(i, oArray[i])).toArray()]
JavaScript: oEntries = [...oArray.entries()] [note: returns an array of arrays] [also (returns an iterator): oEntries = oArray.entries()]
Kotlin: oEntries = oArray.mapIndexed{k,v->k to v!!}.toMap().entries
PHP: foreach ($oArray as $vKey=>$vValue) array_push($oEntries, [$vKey, $vValue]) [beforehand: $oEntries = []] [also: $oEntries = array_map(function($oKey) use ($oArray) {return [$oKey, $oArray[$oKey]];}, array_keys($oArray))]
Python: oEntries = {k:v for k,v in enumerate(oList)}.items()
R: oEntries = Map(c, 1:length(oVec), oVec, USE.NAMES=FALSE) [note: 1-based] [also (0-based): oEntries = Map(c, 0:(length(oVec)-1), oVec, USE.NAMES=FALSE)]
Ruby: oEntries = oArray.each_with_index.map{|v,k| [k,v]}
Rust: oEntries = oArray.iter().enumerate().collect::<Vec<_>>()
Scala: oEntries = oArray.zipWithIndex [note: an array of tuples] [also (2D array): oEntries = oArray.zipWithIndex.map((v,k)=>Array(k,v))]
Swift: oEntries = oArray.enumerated().map{[$0,$1]} [also (to tuples): oEntries = oArray.enumerated().map{($0,$1)}]
UFL: Array.Flat [or Array.Flatten][note: modifies the array][see also: Array.FlatMap][see also (inverse): Array.Chunk][e.g. 2D array to 1D array]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___ [can use: oArray = oArray.flatten]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: oArray.flat(vDepth) [note: default depth: 1]
Kotlin: oArray.flatten()
PHP: ___
Python: ___ [can use: oListNew = reduce(list.__add__, oList)] [requires: from functools import reduce] [also: oListNew = list(itertools.chain.from_iterable(oList))] [requires: import itertools] [note (both): flattens by depth 1]
R: ___
Ruby: oArray.flatten!
Rust: ___
Scala: ___ [can use: oArray = oArray.flatten]
Swift: ___
UFL: (Array.Flattened) [note: doesn't modify the array (creates a new array)][e.g. 2D array to 1D array]
AutoHotkey: ___
C++: ___ [e.g. 2D array: for (const auto& oEntry : oEntries) oVec.insert(oVec.end(), oEntry, oEntry+2)] [beforehand (e.g.): std::vector<std::string> oVec] [beforehand (e.g.) std::vector<int> oVec]
C#: oArrayNew = oArray.SelectMany(v=>v)
Crystal: oArrayNew = oArray.flatten
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [e.g. flatten String[][]: String[] oArray = Arrays.stream(oEntries).flatMap(Arrays::stream).toArray(String[]::new)] [e.g. flatten int[][]: int[] oArray = Arrays.stream(oEntries).flatMapToInt(Arrays::stream).toArray()] [also: String[] oArray = Stream.of(oEntries).flatMap(Stream::of).toArray(String[]::new)] [also: int[] oArray = Stream.of(oEntries).flatMapToInt(IntStream::of).toArray()]
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: ___
Ruby: oArrayNew = oArray.flatten
Rust: ___ [can use (vector of vectors): oVecNew = oEntries.clone().into_iter().flatten().collect::<Vec<_>>()] [can use (array of arrays, vector of vectors): for oEntry in oEntries.clone() {for vValue in oEntry {oVecNew.push(vValue);}}] [beforehand (a of a, v of v): let mut oVecNew: Vec<&str> = vec![]]
Scala: oArrayNew = oArray.flatten
Swift: oArrayNew = oArray.flatMap{$0} [WARNING: only flattens by 1 level]
UFL: Array.Length [get length/count/size (element count)]
AutoHotkey: oArray.Length [note: AHK v1: oArray.Length()]
C++: sizeof(oArray)/sizeof(oArray[0]) [also: vLen = *(&oArray+1) - oArray] [note (std::vector): oVec.size()] [also: vLen = std::end(oArray) - std::begin(oArray)]
C#: oArray.Length [also: oList.Count]
Crystal: oArray.size
Excel: ___
Excel VBA: vLen = UBound(oArray) - LBound(oArray) + 1 [note: this works for empty arrays too, e.g. Array() has UBound -1 and LBound 0]
Go: len(oArray)
Java: oArray.length [also: oList.size()] [WARNING: oArray.length requires no parentheses, unlike vText.length()]
JavaScript: oArray.length
Kotlin: oArray.size [also: oArray.count()]
PHP: count($oArray) [also: sizeof($oArray)]
Python: len(oList)
R: length(oVec)
Ruby: oArray.length [also: oArray.size] [also: oArray.count]
Rust: oArray.len() [also: oVec.len()]
Scala: oArray.length [also: oArray.size] [also: oList.length] [also: oList.size]
Swift: oArray.count
UFL: Array.CountNonNull [no params: count items with a value][e.g. check if array is dense]
AutoHotkey: ___
C++: for (const auto& vValue : oArray) if (vValue != (std::string)NULL) vCount++ [beforehand: int vCount = 0]
C#: vCount = oArray.Count(v=>v!=null)
Crystal: vCount = oArray.count{|v| v!=nil}
Excel: ___
Excel VBA: ___ [note: can use Filter() to list matches(/non-matches) that are a *substring* of a needle, case-sensitive/case-insensitive (integer values are treated as strings)]
Go: ___
Java: ___ [e.g. Integer[]: int vCount = Arrays.stream(oArray).reduce(0,(a,v)->a+(v!=null?1:0))]
JavaScript: ___
Kotlin: ___
PHP: $vCount = count(array_filter($oArray, function($oValue) {return ($oValue != null);}))
Python: ___
R: vCount = length(na.omit(oVec)) [count elements excluding any NA elements]
Ruby: vCount = oArray.count{|v| v!=nil}
Rust: vCount = oArray.iter().fold(0, |a,v| a+(*v).is_none() as i32)
Scala: ___ [can use: oArray.count(_!=null)]
Swift: vCount = oArray.reduce(0){$0+($1==nil ?1:0)} [note: if '?' 'has no whitespace on the left, it's treated as a postfix operator']
UFL: Array.Count [or Array.CountMatch][1 param: count items that match predicate (i.e. like Array.Filter but the count only, not the matches)][see also: Array.Filter/Array.Reduce]
AutoHotkey: ___
C++: ___ [can use: vCount = std::accumulate(oVec.begin(), oVec.end(), 0, [vNeedle](int a,int v){return a+(v==vNeedle);})] [also: for (const auto& vValue : oArray) if (vValue == vNeedle) vCount++] [beforehand: int vCount = 0] [requires: #include <numeric>]
C#: vCount = oArray.Count(oFunc) [also: vCount = oArray.Count(v=>oFunc(v))]
Crystal: vCount = oArray.count(&oFunc) [also: vCount = oArray.count{|v| oFunc.call(v)}]
Excel: ___
Excel VBA: ___ [note: can use Filter() to list matches(/non-matches) that are a *substring* of a needle, case-sensitive/case-insensitive (integer values are treated as strings)]
Go: ___
Java: ___ [can use (int[]): int vCount = Arrays.stream(oArray).boxed().reduce(0,(a,v)->a+(v==vNeedle?1:0))] [also (int[]): long vCount = Arrays.stream(oArray).boxed().filter(v->v==vNeedle).count()] [can use (String[]): int vCount = Arrays.stream(oArray).reduce(0,(a,v)->a+(v==vNeedle?1:0),Integer::sum)] [also (String[]): long vCount = Arrays.stream(oArray).filter(v->v==vNeedle).count()]
JavaScript: ___ [can use: vCount = oArray.reduce((a,v)=>a+(v==vNeedle), 0)] [also: vCount = oArray.filter(oFunc).length]
Kotlin: vCount = oArray.count(oFunc)
PHP: ___ [can use: $vCount = array_reduce($oArray, fn($a,$v)=>$a+($v==$vNeedle))] [also: $vCount = count(array_filter($oArray, function($oValue) use ($vNeedle) {return ($oValue == $vNeedle);}))]
Python: ___ [can use: vCount = reduce(lambda a,v:a+(v==vNeedle), oList, 0)] [also: vCount = len(list(filter(oFunc, oList)))] [requires (reduce): from functools import reduce]
R: ___ [can use: vCount = Reduce(\(a,v) a+(v==vNeedle), oVec, 0)] [also: vCount = length(Filter(oFunc, oVec))] [also (unusual syntax): vCount = length(oVec[oFunc(oVec)])] [e.g. (unusual syntax): vCount = length(oVec[oVec%%3 == 0])] [note: Filter() excludes NA values]
Ruby: vCount = oArray.count(&oFunc) [also: vCount = oArray.count{|v| oFunc.call(v)}]
Rust: ___ [can use: vCount = oArray.iter().fold(0, |a,v| a+(*v==vNeedle) as i32)] [also: vCount = oArray.iter().filter(|v| oFunc(**v)).count()]
Scala: vCount = oArray.count(oFunc) [also: vCount = oArray.count(_==vNeedle)] [also: vCount = oArray.count(v=>v==vNeedle)]
Swift: ___ [can use: vCount = oArray.reduce(0){$0+($1==vNeedle ?1:0)}] [also: vCount = oArray.filter(oFunc).count]
UFL: Array.All [check that all items match the predicate][see also: Array.Count/Array.Any]
AutoHotkey: ___
C++: std::all_of(std::begin(oArray), std::end(oArray), oFunc) [requires (all_of): #include <algorithm>]
C#: oArray.All(oFunc) [also: Array.TrueForAll(oArray, oFunc)] [requires (All): using System.Linq]
Crystal: oArray.all?(&oFunc) [also: oArray.all?{|v| oFunc.call(v)}]
Excel: ___
Excel VBA: ___
Go: ___
Java: Arrays.stream(oArray).allMatch(oFunc)
JavaScript: oArray.every(oFunc)
Kotlin: oArray.all(oFunc) [also: oArray.all{oFunc(it)}]
PHP: ___
Python: all(oFunc(v) for v in oList)
R: all(oFunc(oVec)) [also: all(oVecBool)] [e.g. all(c(1,2,3)%%3 == 0)] [e.g. all(c(TRUE,TRUE,FALSE))]
Ruby: oArray.all?(&oFunc) [also: oArray.all?{|v| oFunc.call(v)}]
Rust: oArray.iter().all(|&v| oFunc(v))
Scala: oArray.forall(oFunc)
Swift: oArray.allSatisfy(oFunc) [also: oArray.allSatisfy{oFunc($0)}] [also: !oArray.contains(where:{!oFunc($0)})] [note: i.e. where it doesn't contain a non-match]
UFL: Array.Any [check that at least 1 item matches the predicate][see also: Array.Count/Array.All/Array.HasVal/Array.IndexOf]
AutoHotkey: ___
C++: std::any_of(std::begin(oArray), std::end(oArray), oFunc) [requires (any_of): #include <algorithm>]
C#: oArray.Any(oFunc) [also: Array.Exists(oArray, oFunc)] [requires (Any): using System.Linq]
Crystal: oArray.any?(&oFunc) [also: oArray.any?{|v| oFunc.call(v)}]
Excel: ___
Excel VBA: ___
Go: ___
Java: Arrays.stream(oArray).anyMatch(oFunc)
JavaScript: oArray.some(oFunc)
Kotlin: oArray.any(oFunc) [also: oArray.any{oFunc(it)}]
PHP: ___
Python: any(oFunc(v) for v in oList)
R: any(oFunc(oVec)) [also: any(oVecBool)] [e.g. any(c(1,2,3)%%3 == 0)] [e.g. any(c(TRUE,TRUE,FALSE))]
Ruby: oArray.any?(&oFunc) [also: oArray.any?{|v| oFunc.call(v)}]
Rust: oArray.iter().any(|&v| oFunc(v))
Scala: oArray.exists(oFunc)
Swift: oArray.contains(where:oFunc)
UFL: Array.None [check that no items match the predicate][see also: Array.Count/Array.All]
AutoHotkey: ___
C++: std::none_of(std::begin(oArray), std::end(oArray), oFunc) [requires (none_of): #include <algorithm>]
C#: ___ [can use: !oArray.Any(oFunc)] [also: !Array.Exists(oArray, oFunc)] [requires (Any): using System.Linq]
Crystal: oArray.none?(&oFunc) [also: oArray.none?{|v| oFunc.call(v)}]
Excel: ___
Excel VBA: ___
Go: ___
Java: Arrays.stream(oArray).noneMatch(oFunc)
JavaScript: ___ [can use: !oArray.some(oFunc)]
Kotlin: oArray.none(oFunc) [also: oArray.none{oFunc(it)}]
PHP: ___
Python: ___ [can use: not any(oFunc(v) for v in oList)]
R: ___ [can use: !any(oFunc(oVec))] [also: !any(oVecBool)]
Ruby: oArray.none?(&oFunc) [also: oArray.none?{|v| oFunc.call(v)}]
Rust: ___ [can use: !oArray.iter().any(|&v| oFunc(v))]
Scala: ___ [can use: !oArray.exists(oFunc)]
Swift: ___ [can use: !oArray.contains(where:oFunc)]
UFL: Array.GetCapacity [get array capacity][see also: StrGetCapacity]
AutoHotkey: vCapacity := oArray.Capacity
C++: vCapacity = oVec.capacity()
C#: vCapacity = oList.Capacity
Crystal: ___ [can use: oArray.remaining_capacity]
Excel: ___
Excel VBA: ___
Go: vCapacity := cap(oSlice)
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: vCapacity = oArray.capacity()
Scala: ___
Swift: vCapacity = oArray.capacity
UFL: Array.SetCapacity [set array capacity (or request a minimum capacity)][see also: StrSetCapacity]
AutoHotkey: oArray.Capacity := vCapacity
C++: oVec.reserve(vCapacity) [also: oVec.shrink_to_fit()]
C#: oList.Capacity = vCapacity
Crystal: ___ [can use (for new arrays): oArray(Int32).new(vCapacity)]
Excel: ___
Excel VBA: ___
Go: oSlice = slices.Grow(oSlice, vCapacityToAdd) [WARNING: value is capacity to *add*, not the future total] [also (shrink to fit): oSlice = slices.Clip(oSlice)]
Java: oList.ensureCapacity(vCapacity) [also: oList.trimToSize()]
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: ___ [WARNING (reserve): value is capacity to *add*, not the future total] [e.g. add: oArray.reserve(vCapacityExtra)] [e.g. set total: oArray.reserve(vCapacity-oArray.len())] [also: reserve_exact/shrink_to_fit/shrink_to/truncate]
Scala: ___
Swift: oArray.reserveCapacity(vCapacity)
UFL: Array.Has [or Array.HasKey][i.e. is the *index* within bounds]
AutoHotkey: vHasKey := oArray.Has(vKey)
C++: vHasKey = (vKey < sizeof(oArray)/sizeof(oArray[0])) [also: (oArray[vKey] != (std::string)NULL)]
C#: vHasKey = (vKey < oArray.Length) [also: (oArray[vKey] != null)]
Crystal: vHasKey = (vKey < oArray.size) [also: oArray.count]
Excel: ___
Excel VBA: vHasKey = (TypeName(oArray(vKey)) != "Empty") [also: vHasKey = (LBound(oArray) <= vKey) And (vKey <= UBound(oArray))]
Go: vHasKey := (vKey < len(oArray))
Java: var vHasKey = (vKey < oArray.length) [also: (oArray[vKey] != null)]
JavaScript: vHasKey = (vKey in oArray) [note: empty (elided) items return false, undefined/null items return true]
Kotlin: vHasKey = (vKey < oArray.size) [also: (oArray[vKey] != null)]
PHP: $vHasKey = array_key_exists($vKey, $oArray)
Python: vHasKey = (vKey < len(oList)) [also: (oList[vKey] is not None)]
R: vHasKey = (vKey <= length(oVec)) [also: vHasKey = !is.na(oVec[vKey])] [note: 1-based]
Ruby: vHasKey = (vKey < oArray.length) [also: oArray.size] [also: oArray.count]
Rust: vHasKey = (vKey < oArray.len()) [also: vHasKey = (vKey < oVec.len())] [also: !oArray[vKey].is_none()] [also: !oVec[vKey].is_none()] [also: is_some()]
Scala: vHasKey = (vKey < oArray.length) [also: (oArray(vKey) != null)]
Swift: vHasKey = (vKey < oArray.count) [also: oArray[vKey] != nil]
UFL: (Array.KeyIsEmpty) [for a given key, is it empty (non-existent) or null]
AutoHotkey: ___ [can use: IsSet(vVar)] [note: cannot use IsSet(oArray[vKey])] [can use: try oArray[vKey]]
C++: vKeyIsEmpty = (oArray[vKey] == (std::string)NULL)
C#: vKeyIsEmpty = (oArray[vKey] == null)
Crystal: vKeyIsEmpty = (oArray[vKey] == nil)
Excel: ___
Excel VBA: vKeyIsEmpty = (TypeName(oArray(vKey)) = "Empty")
Go: ___
Java: var vKeyIsEmpty = (oArray[vKey] == null)
JavaScript: vKeyIsEmpty = !(vKey in oArray)
Kotlin: vKeyIsEmpty = (oArray[vKey] == null)
PHP: $vKeyIsEmpty = ($oArray[$vKey] == null)
Python: vKeyIsEmpty = (oList[vKey] is None) [inverse: (oList[vKey] is not None)]
R: vKeyIsEmpty = is.na(oVec[vKey])
Ruby: vKeyIsEmpty = (oArray[vKey] == nil)
Rust: vKeyIsEmpty = oArray[vKey].is_none() [also: vKeyIsEmpty = oVec[vKey].is_none()]
Scala: vKeyIsEmpty = (oArray(vKey) == null)
Swift: vKeyIsEmpty = (oArray[vKey] == nil)
UFL: Array.HasVal [or Array.HasValue/Array.Contains][array contains/includes value (value exists)][see also: Array.IndexOf/Array.Any/Array.Find]
AutoHotkey: ___
C++: auto vHasVal = (std::find(std::begin(oArray), std::end(oArray), vNeedle) == std::end(oArray)) [also: auto vHasVal = (std::find(oVec.begin(), oVec.end(), vNeedle) == oVec.end())]
C#: vHasVal = oArray.Contains(vNeedle) [also: vHasVal = Array.Exists(oArray, v=>v==vNeedle)]
Crystal: vHasVal = oArray.includes?(vNeedle)
Excel: ___
Excel VBA: ___ [note: can use Filter() to list matches(/non-matches) that are a *substring* of a needle, case-sensitive/case-insensitive (integer values are treated as strings)]
Go: vHasVal := slices.Contains(oSlice, vNeedle)
Java: ___ [can use: var vHasVal = (oList.indexOf(vNeedle) != -1)] [also (String[]): var vHasVal = Arrays.asList(oArray).contains(vNeedle)] [also (String[]): var vHasVal = Arrays.stream(oArray).anyMatch(vNeedle::equals)] [also (int[]): var vHasVal = IntStream.of(oArray).anyMatch(v->v==vNeedle)]
JavaScript: vHasVal = oArray.includes(vNeedle)
Kotlin: vHasVal = oArray.contains(vNeedle)
PHP: $vHasVal = in_array($vNeedle, $oArray)
Python: vHasVal = vNeedle in oList [inverse: vNeedle not in oList] [also (throws if no match): vKey = oList.index(vNeedle)]
R: vHasVal = vNeedle %in% oVec [also: vHasVal = is.element(vNeedle, oVec)] [note (both): also works with lists]
Ruby: vHasVal = oArray.include?(vNeedle) [also: vHasVal = oArray.member?(vNeedle)]
Rust: vHasVal = oArray.contains(vNeedle) [also: vHasVal = oVec.contains(vNeedle)]
Scala: vHasVal = oArray.contains(vNeedle) [note: also works with lists]
Swift: vHasVal = oArray.contains(vNeedle)
UFL: Array.IndexOf [potentially also: (Array.IndexOf0B)/(Array.IndexOf1B) (note: typically return -1 or 0 if no match)][see also: Array.HasVal/Array.Any/Array.Find]
AutoHotkey: ___
C++: auto vIndex = std::find(std::begin(oArray), std::end(oArray), vNeedle) - oArray [also: auto vIndex = std::find(oVec.begin(), oVec.end(), vNeedle) - oVec.begin()] [note (both): returns array length (or vector size) if no match]
C#: vKey = Array.IndexOf(oArray, vNeedle) [note: returns -1 if no match ('the lower bound of the array minus 1')]
Crystal: vKey = oArray.index(vNeedle) || -1 [note: index() returns nil if no match]
Excel: ___
Excel VBA: ___
Go: vKey := slices.Index(oSlice, vNeedle) [note: returns -1 if no match]
Java: vKey = oList.indexOf(vNeedle) [note: returns -1 if no match]
JavaScript: vKey = oArray.indexOf(vNeedle) [note: returns -1 if no match]
Kotlin: vKey = oArray.indexOf(vNeedle) [note: returns -1 if no match]
PHP: $vKey = array_search($vNeedle, $oArray) [WARNING: returns false if no match] [note: since PHP arrays are associative arrays, -1 is a valid key name, hence boolean false is returned if no match]
Python: vKey = oList.index(vNeedle) [WARNING: throws if no match]
R: vKey = match(vNeedle, oVec) [note: returns NA if no match] [also (returns 0 if no match): vKey = match(vNeedle, oVec, nomatch=0)]
Ruby: vKey = oArray.index(vNeedle) || -1 [note: index() returns nil if no match]
Rust: oOpt = oArray.iter().position(|&v| v==vNeedle) [e.g. vIsMatch = oOpt.is_some()] [e.g. vValue = oOpt.unwrap_or(vDefault)] [e.g. vValue = oOpt.unwrap()] [also: vKey: i32 = oArray.iter().position(|&v| v==vNeedle).map_or(-1, |v| v as i32)] [note: also works with vectors]
Scala: vKey = oArray.indexOf(vNeedle) [note: returns -1 if no match] [note: also works with lists]
Swift: oOpt = oArray.firstIndex(of:vNeedle) [e.g. vIsMatch = (oOpt != nil)] [e.g. vKey = oOpt!] [also: vKey = oArray.firstIndex(of:vNeedle) ?? -1]
UFL: Array.LastIndexOf [(note: typically return -1 or 0 if no match)]
AutoHotkey: ___
C++: auto vIndex = oVec.rend() - std::find(oVec.rbegin(), oVec.rend(), vNeedle) - 1 [note: returns -1 if no match]
C#: vKey = Array.LastIndexOf(oArray, vNeedle) [note: returns -1 if no match]
Crystal: vKey = oArray.rindex(vNeedle) || -1 [note: rindex() returns nil if no match]
Excel: ___
Excel VBA: ___
Go: ___
Java: vKey = oList.lastIndexOf(vNeedle) [note: returns -1 if no match]
JavaScript: vKey = oArray.lastIndexOf(vNeedle) [note: returns -1 if no match]
Kotlin: vKey = oArray.lastIndexOf(vNeedle) [note: don't confuse with indexOfLast] [note: returns -1 if no match]
PHP: $vKey = array_search($vNeedle, array_reverse($oArray, true)) [note: array_reverse() doesn't modify the array] [note: array_reverse(): preserve_keys set to true] [WARNING: since PHP arrays are associative arrays, -1 is a valid key name, hence boolean false is returned if no match]
Python: vKey = max(k for k,v in enumerate(oList) if v==vNeedle) [WARNING: throws if no match, consistent with oList.index()]
R: vKey = length(oVec) + 1 - match(vNeedle, rev(oVec)) [note: returns NA if no match] [also (returns 0 if no match): vKey = length(oVec) + 1 - match(vNeedle, rev(oVec), nomatch=length(oVec)+1)] [also (returns NA if no match): tail(c(NA, which(oVec %in% vNeedle)), 1)]
Ruby: vKey = oArray.rindex(vNeedle) || -1 [note: rindex() returns nil if no match]
Rust: oOpt = oArray.iter().rposition(|&v| v==vNeedle) [e.g. vIsMatch = oOpt.is_some()] [e.g. vValue = oOpt.unwrap_or(vDefault)] [e.g. vValue = oOpt.unwrap()] [also: vKey: i32 = oArray.iter().rposition(|&v| v==vNeedle).map_or(-1, |v| v as i32)] [note: also works with vectors]
Scala: vKey = oArray.lastIndexOf(vNeedle) [note: returns -1 if no match] [note: also works with lists]
Swift: oOpt = oArray.lastIndex(of:vNeedle) [e.g. vIsMatch = (oOpt != nil)] [e.g. vKey = oOpt!] [also: vKey = oArray.lastIndex(of:vNeedle) ?? -1]
UFL: Array.Find [or Array.FirstMatch][get value of first item that matches predicate][workaround: use a filter and return the first value][see also: Array.Filter/OpNullCoalescing/Array.IndexOf]
AutoHotkey: ___
C++: auto oIter = std::find_if(oVec.begin(), oVec.end(), oFunc) [afterwards: vIsMatch = (oIter != oVec.end())] [afterwards: vValue = *oIter] [requires (find_if): #include <algorithm>] [also: std::ranges::find_if()]
C#: vValue = oArray.ToList().Find(v=>oFunc(v)) [also: vValue = oArray.ToList().Find(oFunc)] [WARNING: returns the array's default value if no match (e.g. 0 for ints, null for strings)] [requires (ToList): using System.Linq]
Crystal: vValue = oArray.find{|v| oFunc.call(v)} [also: vValue = oArray.find(&oFunc)] [note: returns nil if no match]
Excel: ___
Excel VBA: ___
Go: ___
Java: oOpt = Arrays.stream(oArray).filter(v->oFunc.test(v)).findFirst() [also: oOpt = Arrays.stream(oArray).filter(oFunc).findFirst()] [e.g. vIsMatch = oOpt.isPresent()] [e.g. vValue = oOpt.orElseThrow()]
JavaScript: vValue = oArray.find(v=>oFunc(v)) [also: vValue = oArray.find(oFunc)] [note: returns undefined if no match]
Kotlin: oOpt = oArray.find{oFunc(it)} [also: oOpt = oArray.find(oFunc)] [e.g. vIsMatch = (oOpt != null)] [e.g. vValue = oOpt!!]
PHP: $vValue = current(array_filter($oArray, fn($v)=>$oFunc($v))) [WARNING: returns false if no match]
Python: vValue = next(v for v in oList if oFunc(v)) [also: vValue = next((v for v in oList if oFunc(v)), vDefault)] [note: throws if no match] [note: if specify a default, additional parentheses required, else error: 'Generator expression must be parenthesized']
R: vValue = oVec[oFunc(oVec)][1] [e.g. vValue = oVec[oVec==vNeedle][1]] [note: returns NA if no match]
Ruby: vValue = oArray.find{|v| oFunc.call(v)} [also: vValue = oArray.find(&oFunc)] [note: returns nil if no match]
Rust: oOpt = oArray.into_iter().find(|v| oFunc(*v)) [e.g. vIsMatch = oOpt.is_some()] [e.g. vValue = oOpt.unwrap_or(vDefault)] [e.g. vValue = oOpt.unwrap()]
Scala: oOpt = oArray.find(oFunc) [e.g. vIsMatch = oOpt.isDefined] [e.g. vValue = oOpt.get]
Swift: oOpt = oArray.first{oFunc($0)} [also: oOpt = oArray.first(where:oFunc)] [e.g. vIsMatch = (oOpt != nil)] [e.g. vValue = oOpt!]
UFL: Array.Get [key get value]
AutoHotkey: vValue := oArray[vKey] [note: 1-based] [note: out of bounds: throws]
C++: vValue = oArray[vKey] [also: vValue = oVec.at(vKey)] [also: vValue = oVec[vKey]] [WARNING: oArray[vKey]: if key is out of bounds, it will attempt to read the value anyway] [note: at() throws if key doesn't exist] [WARNING: oVec[vKey]: if key is out of bounds, the behaviour is undefined]
C#: vValue = oArray[vKey] [also: oArray.GetValue(vKey)] [note: out of bounds: throws] [also: vValue = oList[vKey]]
Crystal: vValue = oArray[vKey] [note: out of bounds: throws]
Excel: ___
Excel VBA: vValue = oArray(vKey) [note: out of bounds: throws] [note: arrays are 0-based unless a different start index specified]
Go: vValue := oArray[vKey] [note: out of bounds: throws]
Java: vValue = oArray[vKey] [also: vValue = oList.get(vKey)] [note: out of bounds: throws]
JavaScript: vValue = oArray[vKey] [also (negative indexes relative to end): vValue = oArray.at(vKey)] [note: out of bounds: returns undefined]
Kotlin: vValue = oArray[vKey] [also: vValue = oArray.get(vKey)] [note: out of bounds: oArray[] and oArray.get() throw]
PHP: $vValue = $oArray[$vKey] [note: out of bounds: throws]
Python: vValue = oList[vKey] [note: out of bounds: throws]
R: vValue = oVec[vKey] [note: 1-based] [note: out of bounds: returns NA]
Ruby: vValue = oArray[vKey] [note: out of bounds: returns nil]
Rust: vValue = oArray[vKey] [note: out of bounds: throws] [also: vValue = oVec[vKey]] [WARNING (array/vector): get() returns a wrapped value]
Scala: vValue = oArray(vKey) [also: vValue = oList(vKey)] [note: out of bounds: throws]
Swift: vValue = oArray[vKey] [note: out of bounds: throws]
UFL: Array.GetOrDefault [if key non-existent/null/beyond length, provide default (deviations from this are noted)]
AutoHotkey: vValue := oArray.Get(vKey, vDefault) [WARNING: throws if key beyond length]
C++: ___
C#: ___ [can use: oArray.ElementAtOrDefault(vKey)] [WARNING (ElementAtOrDefault): returns null if value is null] [note (ElementAtOrDefault): returns default if key beyond length] [note (ElementAtOrDefault): can't specify a default, the defaults for int/double/string are 0/0/"" respectively] [also: oArray[vKey] ?? vDefault] [WARNING: oArray[vKey] throws if key beyond length]
Crystal: vValue = oArray.fetch(vKey, vDefault) [also: vValue = oArray.fetch(vKey){|k| oFunc.call(k)}] [note: returns default if key beyond length]
Excel: ___
Excel VBA: ___
Go: ___
Java: vValue = Optional.ofNullable(oArray[vKey]).orElse(vDefault) [WARNING: throws if key beyond length]
JavaScript: vValue = oArray[vKey] ?? vDefault [note: returns default if value is null/undefined] [note: returns default if key beyond length]
Kotlin: vValue = oArray.getOrElse(vKey, oFunc) [e.g. oArray.getOrElse(vKey){vDefault}] [e.g. oArray.getOrElse(vKey, {vDefault})] [WARNING (unlike maps): returns null if value is null] [note: returns default if key beyond length] [also: oArray[vKey] ?: vDefault] [WARNING: oArray[vKey] throws if key beyond length]
PHP: $vValue = $oArray[$vKey] ?? $vDefault
Python: ___ [can use: vValue = (oList[vKey:vKey+1]or[vDefault])[0]] [also: (oList[vKey:vKey+1]+[vDefault])[0]] [WARNING (both): returns None if value is None]
R: ___ [can use: vValue = na.omit(c(oVec[vKey], vDefault))[1]] [note: 1-based]
Ruby: vValue = oArray.fetch(vKey, vDefault) [also: vValue = oArray.fetch(vKey){|k| oFunc.call(k)}] [note: returns default if key beyond length]
Rust: ___ [can use (for array/vector of options): oArray[vKey].unwrap_or(vDefault)]
Scala: vValue = Option(oArray(vKey)).getOrElse(vDefault) [WARNING: throws if key beyond length]
Swift: vValue = oArray[vKey] ?? vDefault [WARNING: throws if key beyond length]
UFL: Array.Set [key set value]
AutoHotkey: oArray[vKey] := vValue
C++: oArray[vKey] = vValue [also: oVec[vKey] = vValue]
C#: oArray[vKey] = vValue [also: oArray.SetValue()]
Crystal: oArray[vKey] = vValue
Excel: ___
Excel VBA: oArray(vKey) = vValue
Go: oArray[vKey] = vValue [note: error if use ':=']
Java: oArray[vKey] = vValue [also: oList.set(vKey, vValue)]
JavaScript: oArray[vKey] = vValue [also: (create a new array, negative indexes relative to end): oArrayNew = oArray.with(vKey, vValue)]
Kotlin: oArray[vKey] = vValue [also: oArray.set(vKey, vValue)]
PHP: $oArray[$vKey] = $vValue
Python: oList[vKey] = vValue
R: oVec[vKey] = vValue
Ruby: oArray[vKey] = vValue
Rust: oArray[vKey] = vValue
Scala: oArray(vKey) = vValue [also: oList = oList.updated(vKey, vValue)]
Swift: oArray[vKey] = vValue
UFL: (Array.Fill) [or Array.SetAll][set all keys to the same value][see also: Array.Rept]
AutoHotkey: ___
C++: std::fill(std::begin(oArray), std::end(oArray), vValue) [also (vector): std::fill(oVec.begin(), oVec.end(), vValue)]
C#: Array.Fill(oArray, vValue)
Crystal: oArray.fill(vValue)
Excel: ___
Excel VBA: ___
Go: ___
Java: java.util.Arrays.fill(oArray, vValue)
JavaScript: oArray.fill(vValue)
Kotlin: oArray.fill(vValue)
PHP: ___ [can use: $oArray = array_fill_keys(array_keys($oArray), $vValue)] [also: $oArray = array_fill(0, count($oArray), $vValue)]
Python: ___ [can use: oList[:] = [vValue for _ in oList]] [also: oList = [vValue] * len(oList)] [also: oList = [vValue for _ in oList]]
R: oVec[] = vValue
Ruby: oArray.fill(vValue)
Rust: oArray.fill(vValue) [also: oVec.fill(vValue)]
Scala: ___ [can use: oArray = Array.fill(oArray.length)(vValue)]
Swift: ___ [can use: oArray = Array(repeating:vValue, count:oArray.count)]
UFL: Array.Swap [swap 2 elements][note: modifies the array]
AutoHotkey: ___
C++: std::swap(oArray[vKey1], oArray[vKey2]) [also: std::iter_swap(oVec.begin()+vKey1, oVec.begin()+vKey2)] [requires (iter_swap): #include <algorithm>]
C#: (oArray[vKey1], oArray[vKey2]) = (oArray[vKey2], oArray[vKey1]) [note: destructuring assignment]
Crystal: oArray.swap(vKey1, vKey2) [also (destructuring assignment): oArray[vKey1], oArray[vKey2] = oArray[vKey2], oArray[vKey1]]
Excel: ___
Excel VBA: ___
Go: oArray[vKey1], oArray[vKey2] = oArray[vKey2], oArray[vKey1] [note: destructuring assignment]
Java: ___
JavaScript: ___
Kotlin: ___
PHP: [$oArray[$vKey1], $oArray[$vKey2]] = [$oArray[$vKey2], $oArray[$vKey1]] [note: destructuring assignment]
Python: oList[vKey1], oList[vKey2] = oList[vKey2], oList[vKey1] [note: destructuring assignment]
R: ___
Ruby: oArray[vKey1], oArray[vKey2] = oArray[vKey2], oArray[vKey1] [note: destructuring assignment]
Rust: oArray.swap(vKey1, vKey2) [also: oVec.swap(vKey1, vKey2)]
Scala: ___ [can use: oArray = oArray.updated(vKey1, oArray(vKey2)).updated(vKey2, oArray(vKey1))]
Swift: oArray.swapAt(vKey1, vKey2) [also (destructuring assignment): (oArray[vKey1], oArray[vKey2]) = (oArray[vKey2], oArray[vKey1])] [note: swap() fails with 'overlapping accesses' error: swap(&oArray[vKey1], &oArray[vKey2])]
UFL: (Array.Swapped) [note: doesn't modify the array (creates a new array)]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: ___ [can use: oArrayNew = oArray.updated(vKey1, oArray(vKey2)).updated(vKey2, oArray(vKey1))]
Swift: ___
UFL: Array.Push [append one value]
AutoHotkey: oArray.Push(vValue)
C++: oVec.push_back(vValue)
C#: var oArrayNew = oArray.Append(vValue).ToArray() [requires (Append/Concat/ToList): using System.Linq] [also: var oArray = oArray.Concat(new[]{vValue}).ToArray()] [also: Array.Resize(ref oArray, oArray.Length+1); oArray[oArray.GetUpperBound(0)] = vValue] [also: var oList = oArray.ToList(); oList.Add(vValue); var oArrayNew = oList.ToArray()]
Crystal: oArray.push(vValue) [also: oArray << vValue]
Excel: ___
Excel VBA: ReDim Preserve oArray(UBound(oArray) + 1) [afterwards: oArray(UBound(oArray)) = vValue]
Go: oSlice = append(oSlice, vValue)
Java: oList.add(vValue)
JavaScript: oArray.push(vValue)
Kotlin: oArray.add(vValue)
PHP: array_push($oArray, $vValue) [note: it finds the maximum (non-negative) integer key n, and creates key n+1, else creates key 0]
Python: oList.append(vValue)
R: oVec = c(oVec, vValue)
Ruby: oArray.push(vValue) [also: oArray << vValue]
Rust: oVec.push(vValue)
Scala: oArray :+= vValue [also: oArrayNew = oArray :+ vValue] [note (both): also works with lists]
Swift: oArray.append(vValue)
UFL: Array.PushMult [or Array.PushArray][append multiple values][append suffix values][modify an array by appending (the values of) another array to it (concatenate arrays)]
AutoHotkey: oArray.Push(oArraySfx*)
C++: oVec.insert(oVec.end(), oVecSfx.begin(), oVecSfx.end()) [can use (to create a new array): auto* oArrayNew = new std::string[vSize+vSizeSfx]] [can use (to copy elements): std::copy()] [requires (copy): #include <algorithm>]
C#: var oArrayNew = oArray.Concat(oArraySfx).ToArray() [requires (Concat/ToList): using System.Linq] [also: var oList = oArray.ToList(); oList.AddRange(oArraySfx); var oArrayNew = oList.ToArray()] [also: CopyTo()] [also: Resize() and Copy()]
Crystal: oArray.concat(oArraySfx) [also: oArray += oArraySfx]
Excel: ___
Excel VBA: ___
Go: oSlice = append(oSlice, oSliceSfx...)
Java: oList.addAll(oListSfx) [also (concatenate via arraycopy): System.arraycopy(oArraySfx, 0, oArrayNew, oArray.length, oArraySfx.length)] [beforehand (concatenate via arraycopy): var oArrayNew = Arrays.copyOf(oArray, oArray.length+oArraySfx.length)] [also (concatenate via streams): String[] oArrayNew = Stream.concat(Arrays.stream(oArray), Arrays.stream(oArraySfx)).toArray(String[]::new)] [requires (concatenate via streams): import java.util.stream.*]
JavaScript: oArray.push(...oArraySfx)
Kotlin: oArray += oArraySfx
PHP: array_push($oArray, ...$oArraySfx) [also: $oArrayNew = array_merge($oArray, $oArraySfx)]
Python: oList.extend(oListSfx)
R: oVec = c(oVec, oVecSfx)
Ruby: oArray.push(*oArraySfx) [also: oArray.concat(oArraySfx)] [also: oArray += oArraySfx]
Rust: oVec.append(&mut oVecSfx.clone()) [also: oVec.extend(oVecSfx.clone())] [also: oVec.extend(oArraySfx)]
Scala: oArray ++= oArraySfx [also: oArrayNew = oArray ++ oArraySfx] [note (both): also works with lists] [note: concat (++= and ++), and appendedAll (:++= and :++)]
Swift: oArray.append(contentsOf:oArraySfx) [also: oArray += oArraySfx]
UFL: Array.InsertAt [insert one item (and shift item(s) right)][note: state if 'insert at' doesn't allow pushing (inserting at an index one beyond the last element)]
AutoHotkey: oArray.InsertAt(vKey, vValue)
C++: oVec.insert(oVec.begin()+vKey, vValue)
C#: oList.Insert(vKey, vValue) [e.g. var oList = oArray.ToList(); oList.Insert(vKey, vValue); var oArrayNew = oList.ToArray()] [requires (ToList): using System.Linq]
Crystal: oArray.insert(vKey, vValue)
Excel: ___
Excel VBA: ___
Go: oSlice = slices.Insert(oSlice, vKey, vValue)
Java: oList.add(vKey, vValue)
JavaScript: oArray.splice(vKey, 0, vValue)
Kotlin: ___ [can use: oArrayNew = oArray.copyOfRange(0, vKey) + vValue + oArray.copyOfRange(vKey, oArray.size)] [also: oArrayNew = oArray.sliceArray(0..<vKey) + vValue + oArray.sliceArray(vKey..<oArray.size)] [also: var oList = oArray.toMutableList(); oList.add(vKey, vValue); var oArrayNew = oList.toTypedArray()]
PHP: array_splice($oArray, $vKey, 0, [$vValue]) [note: square brackets unnecessary, 'unless the element is an array itself, an object or null']
Python: oList.insert(vKey, vValue)
R: oVec = append(oVec, vValue, after=vKey-1) [note: 1-based]
Ruby: oArray.insert(vKey, vValue)
Rust: oVec.insert(vKey, vValue)
Scala: oArrayNew = oArray.patch(vKey, Array(vValue), 0) [note: also works with lists]
Swift: oArray.insert(vValue, at:vKey)
UFL: Array.InsertAtMult [insert item(s) (and shift item(s) right)][insert infix values][see also: Array.Splice]
AutoHotkey: oArray.InsertAt(vKey, oArrayIfx*)
C++: oVec.insert(oVec.begin()+vKey, oVecIfx.begin(), oVecIfx.end())
C#: oList.InsertRange(vKey, oArrayIfx) [e.g. var oList = oArray.ToList(); oList.InsertRange(vKey, oArrayIfx); var oArrayNew = oList.ToArray()] [requires (ToList): using System.Linq]
Crystal: oArray[vKey...vKey] = oArrayIfx [also: oArray = oArray[0...vKey] + oArrayIfx + oArray[vKey..]]
Excel: ___
Excel VBA: ___
Go: oSlice = slices.Insert(oSlice, vKey, oSliceIfx...)
Java: oList.addAll(vKey, oListIfx)
JavaScript: oArray.splice(vKey, 0, ...oArrayIfx)
Kotlin: ___ [can use: oArrayNew = oArray.copyOfRange(0, vKey) + oArrayIfx + oArray.copyOfRange(vKey, oArray.size)] [also: oArrayNew = oArray.sliceArray(0..<vKey) + oArrayIfx + oArray.sliceArray(vKey..<oArray.size)] [also: var oList = oArray.toMutableList(); oList.addAll(vKey, oArrayIfx.toList()); var oArrayNew = oList.toTypedArray()]
PHP: array_splice($oArray, $vKey, 0, $oArrayIfx)
Python: oList[vKey:vKey] = oListIfx [note: slice assignment]
R: oVec = append(oVec, oVecIfx, after=vKey-1) [note: 1-based]
Ruby: oArray.insert(vKey, *oArrayIfx)
Rust: oVec.splice(vKey..vKey, oVecIfx.iter().cloned()) [also: oVec.splice(vKey..vKey, oArrayIfx.iter().cloned())]
Scala: oArrayNew = oArray.patch(vKey, oArrayIfx, 0) [note: also works with lists]
Swift: oArray.insert(contentsOf:oArrayIfx, at:vKey)
UFL: (Array.Prepend) [or Array.InsertAtStart][insert one item at start (and shift item(s) right)]
AutoHotkey: oArray.InsertAt(1, vValue)
C++: oVec.insert(oVec.begin(), vValue)
C#: var oArrayNew = oArray.Prepend(vValue).ToArray() [requires (Concat/Prepend/ToList): using System.Linq] [also: var oArrayNew = new[]{vValue}.Concat(oArray).ToArray()] [also: var oList = oArray.ToList(); oList.Insert(0, vValue); var oArrayNew = oList.ToArray()]
Crystal: oArray.unshift(vValue)
Excel: ___
Excel VBA: ___
Go: oSlice = slices.Insert(oSlice, 0, vValue)
Java: oList.add(0, vValue)
JavaScript: oArray.unshift(vValue)
Kotlin: ___ [can use: copyOfRange and +, sliceArray and +, toMutableList and add]
PHP: array_unshift($oArray, $vValue)
Python: oList.insert(0, vValue)
R: oVec = c(vValue, oVec)
Ruby: oArray.unshift(vValue)
Rust: oVec.insert(0, vValue)
Scala: oArray +:= vValue [also: oArrayNew = vValue +: oArray] [note (both): also works with lists]
Swift: oArray.insert(vValue, at:0)
UFL: (Array.PrependMult) [or Array.InsertAtStartMult][insert item(s) at start (and shift item(s) right)][prepend prefix values]
AutoHotkey: oArray.InsertAt(1, oArrayPfx*)
C++: oVec.insert(oVec.begin(), oVecPfx.begin(), oVecPfx.end())
C#: var oArrayNew = oArrayPfx.Concat(oArray).ToArray() [requires (Concat/ToList): using System.Linq] [also: var oList = oArray.ToList(); oList.InsertRange(0, oArrayPfx); var oArrayNew = oList.ToArray()]
Crystal: oArray[0...0] = oArrayPfx [also: oArray = oArrayPfx + oArray]
Excel: ___
Excel VBA: ___
Go: oSlice = slices.Insert(oSlice, 0, oSlicePfx...)
Java: oList.addAll(0, oListPfx)
JavaScript: oArray.unshift(...oArrayPfx)
Kotlin: ___ [can use: copyOfRange and +, sliceArray and +, toMutableList and add]
PHP: array_unshift($oArray, ...$oArrayPfx)
Python: oList[:0] = oListPfx [note: slice assignment]
R: oVec = c(oVecPfx, oVec)
Ruby: oArray.insert(0, *oArrayPfx)
Rust: oVec.splice(0..0, oVecPfx.iter().cloned()) [also: oVec.splice(0..0, oArrayPfx.iter().cloned())]
Scala: oArray ++:= oArrayPfx [also: oArrayNew = oArrayPfx ++: oArray] [note (both): also works with lists]
Swift: oArray.insert(contentsOf:oArrayPfx, at:0)
UFL: Array.Pop [or Array.RemoveLast][remove last value (and typically simultaneously retrieve the last value)][see also: Array.Last]
AutoHotkey: vValue := oArray.Pop()
C++: oVec.pop_back() [beforehand: vValue = oVec.back()]
C#: var oArrayNew = oArray.SkipLast(1).ToArray() [beforehand: vValue = oArray.Last()] [also (beforehand): vValue = oArray[oArray.Length-1]] [requires (SkipLast/Last): using System.Linq]
Crystal: vValue = oArray.pop
Excel: ___
Excel VBA: ReDim Preserve oArray(UBound(oArray) - 1) [beforehand: vValue = oArray(UBound(oArray))]
Go: oSlice = oSlice[:len(oSlice)-1] [beforehand: vValue := oSlice[len(oSlice)-1]]
Java: oList.remove(oList.size()-1) [beforehand: vValue = oList.get(oList.size()-1)] [also: var oArrayNew = Arrays.copyOfRange(oArray, 0, oArray.length-1)]
JavaScript: vValue = oArray.pop()
Kotlin: oArrayNew = oArray.dropLast(1).toTypedArray() [beforehand: var vValue = oArray.last()] [also (beforehand): var vValue = oArray[oArray.size-1]]
PHP: $vValue = array_pop($oArray) [WARNING: removes the last key to be added (not necessarily an integer key, not necessarily the largest integer key)] [can use (to get the key name): array_key_last($oArray)]
Python: vValue = oList.pop()
R: oVecNew = head(oVec, -1) [beforehand: vValue = tail(oVec, 1)]
Ruby: vValue = oArray.pop
Rust: vValue = oVec.pop().unwrap()
Scala: oArrayNew = oArray.dropRight(1) [note: also works with lists]
Swift: vValue = oArray.removeLast() [also: vValue = oArray.popLast()!] [also: oArrayNew = Array(oArray.dropLast())]
UFL: Array.PopMult [or Array.RemoveLastMult][remove multiple values]
AutoHotkey: oArray.RemoveAt(-vCount, vCount)
C++: oVec.resize(oVec.size()-vCount > 0 ? oVec.size()-vCount : 0)
C#: oArrayNew = oArray.SkipLast(vCount).ToArray() [requires (SkipLast): using System.Linq]
Crystal: oArray.pop(vCount)
Excel: ___
Excel VBA: ReDim Preserve oArray(UBound(oArray) - vCount)
Go: oSlice = oSlice[:len(oSlice)-vCount]
Java: var oArrayNew = Arrays.copyOfRange(oArray, 0, oArray.length-vCount) [WARNING: ArrayList.removeRange() has protected access]
JavaScript: oArray.splice(-vCount)
Kotlin: oArrayNew = oArray.dropLast(vCount).toTypedArray()
PHP: array_splice($oArray, -$vCount)
Python: oListNew = oList[:-3]
R: oVecNew = head(oVec, -vCount)
Ruby: oArray.pop(vCount)
Rust: oVec.truncate(oVec.len()-vCount) [also: oVec.drain(oVec.len()-vCount..)] [note: can use saturating_sub to subtract and clamp (to get numbers within bounds)]
Scala: oArrayNew = oArray.dropRight(vCount) [note: also works with lists]
Swift: oArray.removeLast(vCount) [also: oArrayNew = Array(oArray.dropLast(vCount))]
UFL: Array.RemoveAt [remove one item (and shift item(s) left)][WARNING: the return value often differs e.g. removed value/removed values array/modified array]
AutoHotkey: vValue := oArray.RemoveAt(vKey)
C++: oIter = oVec.erase(oVec.begin()+vKey) [beforehand: vValue = oVec.at(vKey)]
C#: oList.RemoveAt(vKey) [note: no return value] [e.g. var oList = oArray.ToList(); oList.RemoveAt(vKey); var oArrayNew = oList.ToArray()] [beforehand: vValue = oList[vKey]] [requires (ToList): using System.Linq]
Crystal: vValue = oArray.delete_at(vKey)
Excel: ___
Excel VBA: ___
Go: oSlice = slices.Delete(oSlice, vKey, vKey+1) [beforehand: vValue := oSlice[vKey]]
Java: vValue = oList.remove(vKey)
JavaScript: oValues = oArray.splice(vKey, 1)
Kotlin: ___ [can use: copyOfRange and +, sliceArray and +, toMutableList and removeAt/subList] [can use: var oList = oArray.toMutableList(); var vValue = oList.removeAt(vKey); oArray = oList.toTypedArray()]
PHP: $oValues = array_splice($oArray, $vKey, 1)
Python: vValue = oList.pop(vKey) [WARNING: called 'pop' but can remove from any location]
R: oVecNew = oVec[-vKey] [beforehand: vValue = oVec[vKey]]
Ruby: vValue = oArray.delete_at(vKey)
Rust: vValue = oVec.remove(vKey)
Scala: oArrayNew = oArray.patch(vKey, oArray.take(0), 1) [beforehand: vValue = oArray(vKey)] [note: also works with lists]
Swift: vValue = oArray.remove(at:vKey)
UFL: Array.RemoveAtMult [remove item(s) (and shift item(s) left)][see also: Array.Splice]
AutoHotkey: oArray.RemoveAt(vKey, vCount)
C++: oVec.erase(oVec.begin()+vKey, oVec.begin()+vKey+vCount)
C#: oList.RemoveRange(vKey, vCount) [e.g. var oList = oArray.ToList(); oList.RemoveRange(vKey, vCount); var oArrayNew = oList.ToArray()] [requires (ToList): using System.Linq]
Crystal: oArray[vKey...vKey+vCount] = oArray[0...0] [also: oArray[vKey...vKey+vCount] = [] of Int32] [also: oArray = oArray.reject!(vIndex...vIndex+vCount)] [also: oArray = oArray.each_with_index.reject{|v,k| (vIndex...vIndex+vCount).includes?(k)}.map{|v|v[0]}.to_a]
Excel: ___
Excel VBA: ___
Go: oSlice = slices.Delete(oSlice, vKey, vKey+vCount)
Java: ___ [WARNING: ArrayList.removeRange() has protected access]
JavaScript: oArray.splice(vKey, vCount)
Kotlin: ___ [can use: copyOfRange and +, sliceArray and +, toMutableList and removeAt/subList]
PHP: array_splice($oArray, $vKey, $vCount)
Python: del oList[vKey:vKey+vCount]
R: oVecNew = oVec[-(vKey:(vKey+vCount-1))]
Ruby: oArray[vKey...vKey+vCount] = [] [also: oArray = oArray.reject.with_index{|v,k| (vIndex...vIndex+vCount).include?k}]
Rust: oVec.drain(vKey..vKey+vCount)
Scala: oArrayNew = oArray.patch(vKey, oArray.take(0), vCountDel) [note: also works with lists]
Swift: oArray.removeSubrange(vKey..<vKey+vCount)
UFL: (Array.RemoveFirst) [remove first item/element]
AutoHotkey: oArray.RemoveAt(1)
C++: oVec.erase(oVec.begin())
C#: var oArrayNew = oArray.Skip(1).ToArray() [requires (Skip): using System.Linq]
Crystal: oArray.shift
Excel: ___
Excel VBA: ___
Go: oSlice = slices.Delete(oSlice, 0, 1)
Java: oList.remove(0) [also: var oArrayNew = Arrays.copyOfRange(oArray, 1, oArray.length)]
JavaScript: oArray.shift()
Kotlin: oArrayNew = oArray.drop(1).toTypedArray() [can use: oList = oArray.toMutableList(), oList.removeFirst(), oArrayNew = oList.toTypedArray()] [can use (instead of removeFirst()): oList.removeAt(0)]
PHP: array_shift($oArray) [note: get name of first key: array_key_first($oArray)]
Python: oList.pop(0) [WARNING: called 'pop' but can remove from any location] [also: del oList[:1]]
R: oVecNew = tail(oVec, -1)
Ruby: oArray.shift
Rust: oVec.remove(0)
Scala: oArrayNew = oArray.drop(1) [also: oArrayNew = oArray.tail] [note (both): also works with lists]
Swift: oArray.removeFirst() [also: oArrayNew = Array(oArray.dropFirst())]
UFL: (Array.RemoveFirstMult) [remove the first n elements]
AutoHotkey: oArray.RemoveAt(1, vCount)
C++: oVec.erase(oVec.begin(), oVec.begin()+vCount)
C#: var oArrayNew = oArray.Skip(vCount).ToArray() [requires (Skip): using System.Linq]
Crystal: oArray.shift(vCount)
Excel: ___
Excel VBA: ___
Go: oSlice = slices.Delete(oSlice, 0, vCount)
Java: var oArrayNew = Arrays.copyOfRange(oArray, vCount, oArray.length) [WARNING: ArrayList.removeRange() has protected access]
JavaScript: oArray.splice(0, vCount)
Kotlin: oArrayNew = oArray.drop(vCount).toTypedArray()
PHP: array_splice($oArray, 0, $vCount)
Python: del oList[:vCount]
R: oVecNew = tail(oVec, -vCount)
Ruby: oArray.shift(vCount)
Rust: oVec.drain(0..vCount)
Scala: oArrayNew = oArray.drop(vCount) [note: also works with lists]
Swift: oArray.removeFirst(vCount) [also: oArrayNew = Array(oArray.dropFirst(vCount))]
UFL: Array.Splice [or Array.RemoveAndInsert][remove n elements (and shift elements left), and insert 0 or more elements][insert infix values][see also: Array.RemoveAtMult/Array.InsertAtMult]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: oArray[vKey...vKey+vCountDel] = oArrayIfx
Excel: ___
Excel VBA: ___
Go: oSlice = slices.Replace(oSlice, vKey, vKey+vCountDel, oSliceIfx...)
Java: ___
JavaScript: oArray.splice(vKey, vCountDel, ...oArrayIfx)
Kotlin: ___
PHP: array_splice($oArray, $vKey, $vCountDel, $oArrayIfx)
Python: oList[vKey:vKey+vCountDel] = oListIfx [note: slice assignment]
R: ___ [can use: oVec = append(oVec[-(vKey:(vKey+vCountDel-1))], oVecIfx, after=vKey-1)]
Ruby: oArray[vKey...vKey+vCountDel] = oArrayIfx
Rust: oVec.splice(vKey..vKey+vCountDel, oVecIfx)
Scala: oArrayNew = oArray.patch(vKey, oArrayIfx, vCountDel)
Swift: oArray.replaceSubrange(vKey..<vKey+vCountDel, with:oArrayIfx)
UFL: Array.Move [remove element at old index, recalculate indexes, reinsert element at new index][e.g. YouTube API: move playlist item to new index][this simple logic guarantees that the element will appear at new index: by definition, oArray.InsertAt(vIndex, vValue), inserts at the desired index][see also: Array.RemoveAt/Array.InsertAt]
AutoHotkey: ___ [can use: vValue := oArray.RemoveAt(vKeyOld)] [afterwards: oArray.InsertAt(vKeyNew, vValue)]
C++: ___ [can use: auto vValue = oVec.at(vKeyOld); oVec.erase(oVec.begin()+vKeyOld); oVec.insert(oVec.begin()+vKeyNew, vValue);]
C#: ___ [can use: var vValue = oArray[vKeyOld]; var oList = oArray.ToList(); oList.RemoveAt(vKeyOld); oList.Insert(vKeyNew, vValue); oArray = oList.ToArray();] [requires (ToList): using System.Linq]
Crystal: ___ [can use: vValue = oArray.delete_at(vKeyOld); oArray.insert(vKeyNew, vValue)]
Excel: ___
Excel VBA: ___
Go: ___ [can use: vValue := oSlice[vKeyOld]; oSlice = slices.Delete(oSlice, vKeyOld, vKeyOld+1); oSlice = slices.Insert(oSlice, vKeyNew, vValue)]
Java: ___ [can use: var vValue = oList.remove(vKeyOld); oList.add(vKeyNew, vValue);]
JavaScript: ___ [can use: vValue = oArray.splice(vKeyOld, 1)[0]; oArray.splice(vKeyNew, 0, vValue);]
Kotlin: ___ [can use: var oList = oArray.toMutableList(); var vValue = oList.removeAt(vKeyOld); oList.add(vKeyNew, vValue); oArray = oList.toTypedArray()]
PHP: ___ [can use: $oValues = array_splice($oArray, $vKeyOld, 1); array_splice($oArray, $vKeyNew, 0, $oValues);]
Python: ___ [can use: vValue = oList.pop(vKeyOld); oList.insert(vKeyNew, vValue)] [WARNING: called 'pop' but can remove from any location]
R: ___ [can use: vValue = oVec[vKeyOld]; oVec = oVec[-vKeyOld]; oVec = append(oVec, vValue, after=vKeyNew-1)] [note: 1-based]
Ruby: ___ [can use: vValue = oArray.delete_at(vKeyOld); oArray.insert(vKeyNew, vValue)]
Rust: ___ [can use: let mut vValue = oVec.remove(vKeyOld); oVec.insert(vKeyNew, vValue);]
Scala: ___ [can use: var vValue = oArray(vKeyOld); oArray = oArray.patch(vKeyOld, oArray.take(0), 1); oArray = oArray.patch(vKeyNew, Array(vValue), 0)]
Swift: ___ [can use: var vValue = oArray.remove(at:vKeyOld); oArray.insert(vValue, at:vKeyNew)]
UFL: Array.Delete [delete a key, but maintain the positions of other keys]
AutoHotkey: oArray.Delete(vKey)
C++: ___
C#: oArray[vKey] = null
Crystal: oArray[vKey] = nil
Excel: ___
Excel VBA: oArray(vKey) = Empty
Go: ___
Java: oArray[vKey] = null
JavaScript: delete oArray[vKey] [note: sets the key to empty (elided)] [also: oArray[vKey] = undefined]
Kotlin: oArray[vKey] = null
PHP: $oArray[$vKey] = null [also: unset($oArray[$vKey])]
Python: oList[vKey] = None
R: oArray[vKey] = NA [note: can't do: oArray[vKey] = NULL]
Ruby: oArray[vKey] = nil
Rust: oArray[vKey] = None [also: oVec[vKey] = None] [note: for arrays/vectors of options]
Scala: oArray(vKey) = null
Swift: oArray[vKey] = nil
UFL: Array.Clear [or Array.DeleteAll/Array.Empty]
AutoHotkey: oArray.Length := 0
C++: ___ [can use (for array on the heap): oArray = new int[0]] [also: oVec.clear()] [also: oVec = {}] [WARNING: oVec.empty() returns whether the vector is empty or not]
C#: Array.Resize(ref oArray, 0)
Crystal: oArray.clear
Excel: ___
Excel VBA: ReDim oArray(0)
Go: oSlice = nil [also (with different side effects): oSlice = oSlice[:0]] [note: both return a slice with 0 elements]
Java: oArray = new int[]{}
JavaScript: oArray.length = 0
Kotlin: oArray.clear()
PHP: $oArray = [] [also: array_splice($oArray, 0, count($oArray))] [note: appears to work even if the array has no '0' key]
Python: oList.clear()
R: oVec = head(oVec, 0)
Ruby: oArray.clear
Rust: oVec.clear()
Scala: oArrayNew = oArray.take(0)
Swift: oArray.removeAll()
UFL: Array.Clone [or Array.Copy][copy the entire array]
AutoHotkey: oArrayNew := oArray.Clone()
C++: std::copy(std::begin(oArray), std::end(oArray), std::begin(oArrayNew)) [also: std::copy(std::begin(oArray), std::end(oArray), oArrayNew)] [also: auto oVecNew = oVec] [also: std::vector<int> oVecNew(oVec)] [also: std::copy(oVec.begin(), oVec.end(), std::back_inserter(oVecNew))] [note: 'oArrayNew = oArray' causes an error] [requires (copy): #include <algorithm>]
C#: oArrayNew = oArray.Clone() as string[] [also: oArrayNew = (string[])oArray.Clone()] [note: replace 'string[]' with the appropriate type]
Crystal: oArrayNew = oArray.clone [also: oArrayNew = oArray.dup]
Excel: ___
Excel VBA: oArrayNew = oArray [WARNING: this creates a copy, not a reference] [i.e. in many languages, this syntax would result in 2 variables pointing to the same object]
Go: oArrayNew := oArray [MAJOR WARNING: for arrays: 'a2 := a' clones, for slices: 's2 := s' creates a reference] [WARNING: this (oArrayNew := oArray) copies (clones) the object, not a reference] [also (clones the object): oSliceNew := slices.Clone(oSlice)] [also (creates a reference): oSliceNew := oSlice]
Java: oArrayNew = oArray.clone()
JavaScript: oArrayNew = oArray.slice()
Kotlin: oArrayNew = oArray.copyOf()
PHP: $oArrayNew = $oArray [WARNING: this creates a copy, not a reference]
Python: oListNew = oList.copy()
R: oVecNew = oVec [WARNING: this creates a copy, not a reference]
Ruby: oArrayNew = oArray.clone [also: oArrayNew = oArray.dup]
Rust: oVecNew = oVec.clone()
Scala: oArrayNew = oArray.clone
Swift: oArrayNew = oArray [WARNING: this creates a copy, not a reference] [also: oArrayNew = oArray.map{$0}]
UFL: Array.SliceTo [create a copy of keys a (inclusive) to b (inclusive)][inclusive end: less common, but more intuitive (than exclusive end)][WARNING: array 'slices' are often references to keys, rather than copies of keys (i.e. often modifying the slice, modifies the original)]
AutoHotkey: ___
C++: auto oVecNew = std::vector<std::string>(oVec.begin()+vKey1, oVec.begin()+vKey2+1)
C#: var oArrayNew = oArray[vKey1..(vKey2+1)] [also: var oArrayNew = oArray.ToList().Take(vKey1..(vKey2+1)).ToArray()] [WARNING: in C#, '..' is end exclusive] [requires (ToList): using System.Linq]
Crystal: oArrayNew = oArray[vKey1..vKey2]
Excel: ___
Excel VBA: ___
Go: oSliceNew = oArray[vKey1 : vKey2+1]
Java: var oArrayNew = Arrays.copyOfRange(oArray, vKey1, vKey2+1) [WARNING: appends default values if endpoint goes beyond array]
JavaScript: oArrayNew = oArray.slice(vKey1, vKey2+1)
Kotlin: oArrayNew = oArray.slice(vKey1..vKey2).toTypedArray()
PHP: $oArrayNew = array_slice($oArray, $vKey1, $vKey2-$vKey1+1)
Python: oListNew = oList[vKey1:vKey2+1]
R: oVecNew = oVec[vKey1:vKey2]
Ruby: oArrayNew = oArray[vKey1..vKey2]
Rust: oVecNew: Vec<_> = oArray[vKey1..=vKey2].iter().collect() [note: also works with vectors]
Scala: oArrayNew = oArray.slice(vKey1, vKey2+1)
Swift: oArrayNew = Array(oArray[vKey1...vKey2])
UFL: Array.SliceUntil [create a copy of keys a (inclusive) to b (exclusive)]
AutoHotkey: ___
C++: auto oVecNew = std::vector<std::string>(oVec.begin()+vKey1, oVec.begin()+vKey2)
C#: var oArrayNew = oArray[vKey1..vKey2] [also: var oArrayNew = oArray.ToList().Take(vKey1..vKey2).ToArray()] [WARNING: in C#, '..' is end exclusive] [requires (ToList): using System.Linq]
Crystal: oArrayNew = oArray[vKey1...vKey2]
Excel: ___
Excel VBA: ___
Go: oSliceNew = oArray[vKey1 : vKey2]
Java: var oArrayNew = Arrays.copyOfRange(oArray, vKey1, vKey2) [WARNING: appends default values if endpoint goes beyond array]
JavaScript: oArrayNew = oArray.slice(vKey1, vKey2)
Kotlin: oArrayNew = oArray.slice(vKey1..<vKey2).toTypedArray()
PHP: $oArrayNew = array_slice($oArray, $vKey1, $vKey2-$vKey1)
Python: oListNew = oList[vKey1:vKey2]
R: oVecNew = oVec[vKey1:(vKey2-1)]
Ruby: oArrayNew = oArray[vKey1...vKey2]
Rust: oVecNew: Vec<_> = oArray[vKey1..vKey2].iter().collect() [note: also works with vectors] [WARNING: in Rust, '..' is end exclusive]
Scala: oArrayNew = oArray.slice(vKey1, vKey2)
Swift: oArrayNew = Array(oArray[vKey1..<vKey2])
UFL: Array.SliceFirst [create a copy of first n keys][see also: Array.First]
AutoHotkey: ___
C++: auto oVecNew = std::vector<std::string>(oVec.begin(), oVec.begin()+vCount)
C#: var oArrayNew = oArray[..vCount] [also: var oArrayNew = oArray.Take(vCount).ToArray()] [WARNING: in C#, '..' is end exclusive]
Crystal: oArrayNew = oArray[...vCount]
Excel: ___
Excel VBA: ___
Go: oSliceNew = oArray[:vCount]
Java: var oArrayNew = Arrays.copyOfRange(oArray, 0, Math.min(vCount, oArray.length))
JavaScript: oArrayNew = oArray.slice(0, vCount)
Kotlin: oArrayNew = oArray.take(vCount).toTypedArray() [also: oArrayNew = oArray.slice(0..<vCount).toTypedArray()]
PHP: $oArrayNew = array_slice($oArray, 0, $vCount)
Python: oListNew = oList[:vCount]
R: oVecNew = head(oVec, vCount)
Ruby: oArrayNew = oArray[...vCount]
Rust: oVecNew: Vec<_> = oArray[0..vCount].iter().collect() [note: also works with vectors] [WARNING: in Rust, '..' is end exclusive]
Scala: oArrayNew = oArray.take(vCount)
Swift: oArrayNew = Array(oArray.prefix(vCount))
UFL: Array.SliceLast [create a copy of last n keys][see also: Array.Last]
AutoHotkey: ___
C++: auto oVecNew = std::vector<std::string>(oVec.end()-vCount, oVec.end())
C#: var oArrayNew = oArray[Math.Max(oArray.Length-vCount, 0)..] [also: var oArrayNew = oArray.TakeLast(vCount).ToArray()] [WARNING: in C#, '..' is end exclusive]
Crystal: oArrayNew = oArray[-vCount..]
Excel: ___
Excel VBA: ___
Go: oSliceNew = oArray[len(oArray)-vCount:]
Java: var oArrayNew = Arrays.copyOfRange(oArray, Math.max(oArray.length-vCount, 0), oArray.length)
JavaScript: oArrayNew = oArray.slice(-vCount)
Kotlin: oArrayNew = oArray.takeLast(vCount).toTypedArray()
PHP: $oArrayNew = array_slice($oArray, -$vCount)
Python: oListNew = oList[-vCount:]
R: oVecNew = tail(oVec, vCount)
Ruby: oArrayNew = oArray[-vCount..]
Rust: oVecNew: Vec<_> = oArray[oArray.len()-vCount..].iter().collect() [note: also works with vectors] [WARNING: in Rust, '..' is end exclusive]
Scala: oArrayNew = oArray.takeRight(vCount)
Swift: oArrayNew = Array(oArray.suffix(vCount))
UFL: Array.First [get the value of the first key][see also: Array.SliceFirst]
AutoHotkey: vValue := oArray[1] [note: 1-based]
C++: vValue = oArray[0] [also: vValue = oVec[0]]
C#: vValue = oArray[0] [also: vValue = oArray.First()] [requires (First): using System.Linq]
Crystal: vValue = oArray[0]
Excel: ___
Excel VBA: vValue = oArray(0)
Go: vValue := oArray[0]
Java: vValue = oArray[0] [also: vValue = oList.get(0)]
JavaScript: vValue = oArray[0]
Kotlin: vValue = oArray[0] [also: vValue = oArray.first()]
PHP: $vValue = $oArray[0]
Python: vValue = oList[0]
R: vValue = oVec[1] [also: vValue = head(oVec, 1)] [note: 1-based]
Ruby: vValue = oArray[0]
Rust: vValue = oArray[0] [also: vValue = oArray.first().unwrap()] [note (both): also works with vectors]
Scala: vValue = oArray.head [note: oArray.tail returns everything except the first element as an array]
Swift: vValue = oArray[0] [also: vValue = oArray.first!]
UFL: Array.Last [get the value of the last key][see also: Array.Length/Array.Pop/Array.SliceLast]
AutoHotkey: vValue := oArray[-1] [also: vValue := oArray[oArray.Length]] [also (AHK v1): vValue := oArray[oArray.Length()]] [note: 1-based]
C++: vValue = oArray[sizeof(oArray)/sizeof(oArray[0])-1] [also: vValue = oVec.back()]
C#: vValue = oArray[oArray.Length-1] [also: vValue = oArray.Last()] [also: vValue = oArray.TakeLast(1).Last()] [also: vValue = oArray.TakeLast(1).ToArray()[0]] [requires (Last): using System.Linq]
Crystal: vValue = oArray[-1] [also: vValue = oArray[oArray.size-1]]
Excel: ___
Excel VBA: vValue = oArray(UBound(oArray))
Go: vValue := oArray[len(oArray)-1]
Java: vValue = oArray[oArray.length-1] [also: vValue = oList.get(oList.size()-1)]
JavaScript: vValue = oArray.at(-1) [also: vValue = oArray[oArray.length-1]] [also: vValue = oArray.slice(-1)[0]]
Kotlin: vValue = oArray.last() [also: vValue = oArray[oArray.size-1]] [also: vValue = oArray.takeLast(1)[0]]
PHP: $vValue = $oArray[count($oArray)-1] [also: $vValue = array_slice($oArray, -1)[0]]
Python: vValue = oList[-1] [also: vValue = oList[len(oList)-1]]
R: vValue = tail(oVec, 1) [also: vValue = oVec[length(oVec)]] [note: 1-based]
Ruby: vValue = oArray[-1] [also: vValue = oArray[oArray.length-1]]
Rust: vValue = oArray[oArray.len()-1] [also: vValue = oArray.last().unwrap()] [note: also works with vectors]
Scala: vValue = oArray.last [note: oArray.tail returns everything except the first element as an array]
Swift: vValue = oArray.last! [also: vValue = oArray[oArray.count-1]]
UFL: Array.ToString [see also: Array.Join/String/Array.Print]
AutoHotkey: ___
C++: ___
C#: ___ [can use: String.Join(vSep, oArray)]
Crystal: oArray.to_s
Excel: ___ [can use: TEXTJOIN()]
Excel VBA: ___ [can use: Join(oArray, vSep)]
Go: fmt.Sprintf("%v", oArray)
Java: java.util.Arrays.toString(oArray) [also (for string arrays): String.join(vSep, oArray)] [WARNING (only prints a type name): oArray.toString()]
JavaScript: String(oArray) [also: oArray.toString()]
Kotlin: oArray.toList().toString() [also (uses ', ' separator): oArray.joinToString()] [WARNING (only prints a type name): oArray.toString()]
PHP: ___ [can use: implode($vSep, $oArray)] [also (alias): join($vSep, $oArray)] [also: var_export($oArray, true)] [also: print_r($oArray, true)]
Python: str(oList)
R: toString(oVec) [also: capture.output(print(oVec))]
Ruby: oArray.to_s
Rust: format!("{:?}", oArray) [can use: oArray.join(vSep)] [also: format!("{:#?}", oArray)] [note: also works with vectors]
Scala: ___ [can use: oArray.mkString(vSep)] [also: String.join(vSep, oArray)] [also: oArray.toList.toString] [WARNING (only prints a type name): oArray.toString]
Swift: String(describing:oArray) [also: oArray.description] [also: String(reflecting:oArray)] [also (for string arrays): oArray.joined(separator:vSep)]
UFL: Array.Concat [join array strings with no separator]
AutoHotkey: ___
C++: ___ [can use (string array): std::string vText = std::accumulate(std::begin(oArray), std::end(oArray), std::string(""))] [also (string vector): std::string vText = std::accumulate(oVec.begin(), oVec.end(), std::string(""))] [requires (accumulate): #include <numeric>]
C#: String.Concat(oArray)
Crystal: oArray.join
Excel: ___ [can use: TEXTJOIN("",, vText1, vText2, vText3)] [note: TEXTJOIN (Excel 2016)]
Excel VBA: Join(oArray, "")
Go: strings.Join(oArray, "") [note: for string arrays only]
Java: String.join("", oArray) [note: for string arrays only] [also (String[]): vText = Arrays.stream(oArray).map(Object::toString).collect(Collectors.joining())] [also (int[]): vText = Arrays.stream(oArray).boxed().map(Object::toString).collect(Collectors.joining())] [requires (Collectors): import java.util.stream.*]
JavaScript: oArray.join("")
Kotlin: oArray.joinToString("")
PHP: implode("", $oArray) [also (alias): join("", $oArray)] [also: implode($oArray)]
Python: "".join(oList) [WARNING: can't do: oList.join("")] [note: for string lists only] [also (for any list): "".join(map(str, oList))]
R: paste(oVec, collapse="")
Ruby: oArray.join
Rust: oArray.concat() [also: oVec.concat()] [note (both): for string arrays only] [also (any array): oArray.map(|v| format!("{}", v)).concat())] [also (any vector): oVec.iter().map(|v| format!("{}", v)).collect::<Vec<_>>().concat())]
Scala: oArray.mkString("") [also: String.join("", oArray)]
Swift: oArray.joined() [note: for string arrays only] [also (any array): oArray.map{String($0)}.joined()]
UFL: Array.Join [see also: Array.ToString][join array strings with a separator]
AutoHotkey: ___
C++: ___ [can use (string array): std::string vText = std::accumulate(std::begin(oArray), std::end(oArray), std::string(""), [&vSep](std::string a,std::string v){return a+v+vSep;})] [also (string vector): std::string vText = std::accumulate(oVec.begin(), oVec.end(), std::string(""), [&vSep](std::string a,std::string v){return a+v+vSep;})] [WARNING (both): adds a trailing separator] [requires (accumulate): #include <numeric>] [note: can replace '[&vSep]' with '[vSep]']
C#: String.Join(vSep, oArray)
Crystal: oArray.join(vSep) [note: no separator if omitted]
Excel: ___ [can use: TEXTJOIN(vSep,, vText1, vText2, vText3)] [note: TEXTJOIN (Excel 2016)]
Excel VBA: Join(oArray, vSep) [note: separator is space if omitted]
Go: strings.Join(oArray, vSep) [note: for string arrays only] [also (for any array): fmt.Sprintf("%v", oArray)] [note (Join): can't omit separator]
Java: String.join(vSep, oArray) [note: for string arrays only] [also (for any array): java.util.Arrays.toString(oArray)] [also (String[]): vText = Arrays.stream(oArray).map(Object::toString).collect(Collectors.joining(vSep))] [also (int[]): vText = Arrays.stream(oArray).boxed().map(Object::toString).collect(Collectors.joining(vSep))] [requires (Collectors): import java.util.stream.*]
JavaScript: oArray.join(vSep) [note: separator is comma if omitted]
Kotlin: oArray.joinToString(vSep) [note: separator is ', ' if omitted]
PHP: implode($vSep, $oArray) [also (alias): join($vSep, $oArray)] [also (no separator): implode($oArray)] [deprecated: implode($oArray, $vSep)]
Python: vSep.join(oList) [WARNING: can't do: oList.join(vSep)] [note: for string lists only] [also (for any list): vSep.join(map(str, oList))]
R: paste(oVec, collapse=vSep) [note: if 'collapse' omitted, double-space separated, and quotes used if strings]
Ruby: oArray.join(vSep) [note: no separator if omitted]
Rust: oArray.join(vSep) [also: oVec.join(vSep)] [note (both): for string arrays only] [also (any array): oArray.map(|v| format!("{}", v)).join(vSep))] [also (any vector): oVec.iter().map(|v| format!("{}", v)).collect::<Vec<_>>().join(vSep))] [note: can't omit separator]
Scala: oArray.mkString(vSep)
Swift: oArray.joined(separator:vSep) [note: for string arrays only] [also (for any array): oArray.description] [also (any array): oArray.map{String($0)}.joined(separator:",")] [note (joined): no separator if omitted]
UFL: Array.Sort [or Array.SortCasSen][note: modifies the array][see also: StrAlphabetize][sorts case-sensitive, according to Unicode codepoints, e.g. 'Q,q,w,W,E,e,r,R' to 'E,Q,R,W,e,q,r,w']
AutoHotkey: ___ [note: Sort can sort a string by a delimiter char] [WARNING (Sort): default sort is alphabetical, to sort numerically: use mode 'N' e.g. vText := Sort(vText, "D" vSep " N")] [WARNING: Sort() is case-insensitive by default (to sort case-sensitively: use mode 'C')]
C++: std::sort(std::begin(oArray), std::end(oArray)) [also: std::sort(oVec.begin(), oVec.end())] [requires (sort): #include <algorithm>]
C#: Array.Sort(oArray, StringComparer.Ordinal) [also: oArray = oArray.OrderBy(v=>v, StringComparer.Ordinal).ToArray()] [requires (OrderBy): using System.Linq]
Crystal: oArray.sort!
Excel: ___
Excel VBA: ___
Go: slices.Sort(oSlice) [also: slices.SortFunc/slices.SortStableFunc] [also: slices.IsSorted]
Java: Arrays.sort(oArray) [note: e.g. works on int[] and String[]] [also: Collections.sort(oList)] [requires (Arrays): import java.util.*]
JavaScript: oArray.sort() [WARNING: default sort is alphabetical, to sort numerically: e.g. oArray.sort((v1,v2)=>v1-v2)]
Kotlin: oArray.sort() [also: oArray.sortWith(oFunc)]
PHP: sort($oArray) [also: usort($oArray, $oFunc)] [WARNING: default sort (SORT_REGULAR): sorts strings alphabetically (compares 2 strings numerically if at least 1 is numeric-looking, a 'numeric string'), sorts ints numerically] [note: to sort alphabetically: e.g. sort($oArray, SORT_STRING)] [note: to sort numerically: e.g. sort($oArray, SORT_NUMERIC)]
Python: oList.sort() [WARNING: default sort: sorts strings alphabetically, sorts ints numerically (no special handling for numeric-looking strings), throws if try to compare int with str] [note: to sort strings numerically: e.g. oList.sort(key=int)]
R: oVec = sort(oVec, method="radix") [note: 'radix' sorts by Unicode codepoints] [note (sort by locale, which may or may not be case-sensitive): oVec = sort(oVec)] [note: get locale (e.g. 'en_US.UTF-8'): Sys.getlocale("LC_COLLATE")] [note: set locale to case-sensitive: e.g. Sys.setlocale("LC_COLLATE", "C")]
Ruby: oArray.sort!
Rust: oArray.sort() [also: oVec.sort()]
Scala: ___ [can use: oArray = oArray.sorted]
Swift: oArray.sort()
UFL: Array.SortCasIns [note: modifies the array][typically compares strings as if both were lower case (or both upper case), e.g. 'Q,q,w,W,E,e,r,R' to 'E,e,Q,q,r,R,w,W'][see also: StrAlphabetizeCasIns/Array.SortLocale]
AutoHotkey: ___ [note: Sort can sort a string by a delimiter char] [WARNING (Sort): default sort is alphabetical, to sort numerically: use 'N' mode e.g. vText := Sort(vText, "D" vSep " N")] [WARNING: Sort() is case-insensitive by default]
C++: ___
C#: Array.Sort(oArray, StringComparer.OrdinalIgnoreCase) [also: oArray = oArray.OrderBy(v=>v, StringComparer.OrdinalIgnoreCase).ToArray()] [requires (OrderBy): using System.Linq]
Crystal: ___ [can use: oArray.sort!{|v1,v2| v1.downcase <=> v2.downcase}] [also (true indicates case-insensitive): oArray.sort!{|v1,v2| v1.to_s.compare(v2.to_s, true)}]
Excel: ___
Excel VBA: ___
Go: ___
Java: Arrays.sort(oArray, String::compareToIgnoreCase) [also: Collections.sort(oList, String.CASE_INSENSITIVE_ORDER)] [requires (Arrays): import java.util.*]
JavaScript: ___ [can use: oArray.sort((v1,v2) => v1.localeCompare(v2, undefined, {sensitivity: "accent"}))] [note (sensitivity/strength): 'accent' considers 'E'/'e' identical, 'case' considers 'e'/'é' identical, 'base' considers all 3 identical, 'variant' considers none identical]
Kotlin: oArray.sortWith(compareBy(String.CASE_INSENSITIVE_ORDER, {it})) [also: oArray.sortBy{it.lowercase()}]
PHP: usort($oArray, "strcasecmp") [also: sort($oArray, SORT_FLAG_CASE | SORT_STRING)]
Python: ___ [can use: oList.sort(key=str.casefold)] [also: oList.sort(key=str.lower)]
R: ___ [can use: oVec = oVec[order(tolower(oVec))]]
Ruby: oArray.sort!(&:casecmp)
Rust: ___
Scala: ___ [can use: oArrayNew = oArray.sortWith(_.toLowerCase < _.toLowerCase)] [note: also works with lists]
Swift: oArray.sort{$0.caseInsensitiveCompare($1) == .orderedAscending} [requires: import Foundation]
UFL: (Array.SortCasInsThenSen) [note: modifies the array][sort case-insensitive, tiebreaker: sort case-sensitive, e.g. 'Q,q,w,W,E,e,r,R' to 'E,e,Q,q,R,r,W,w'][note: where stable sort exists (preserves the order of items considered equal), you can sort sensitive, then insensitive][WARNING: note the different order (insensitive/sensitive): approach 1: case-insensitive sort with case-sensitive tiebreaking, approach 2: case-sensitive sort then case-insensitive sort]
AutoHotkey: ___ [note: Sort can sort a string by a delimiter char] [e.g. vText := Sort(Sort(vText, "D" vSep " C"), "D" vSep)] [WARNING: Sort() is case-insensitive by default]
C++: ___
C#: oArrayNew = oArray.OrderBy(v=>v, StringComparer.OrdinalIgnoreCase).ThenBy(v=>v, StringComparer.Ordinal).ToArray() [requires (OrderBy): using System.Linq] [WARNING: Array.Sort appears to use stable sort within one sort, but not between multiple sorts]
Crystal: ___ [can use: oArray.sort!; oArray.sort!{|v1,v2| v1.downcase <=> v2.downcase}] [also (true indicates case-insensitive): oArray.sort!; oArray.sort!{|v1,v2| v1.to_s.compare(v2.to_s, true)}]
Excel: ___
Excel VBA: ___
Go: ___
Java: Arrays.sort(oArray); Arrays.sort(oArray, String::compareToIgnoreCase); [also: Collections.sort(oList); Collections.sort(oList, String.CASE_INSENSITIVE_ORDER);] [requires (Arrays): import java.util.*]
JavaScript: ___ [can use: oArray.sort((v1,v2) => v1.localeCompare(v2, undefined, {sensitivity: "accent"}) || (+(v1>v2)||-(v1<v2)));]
Kotlin: oArray.sort(); oArray.sortWith(compareBy(String.CASE_INSENSITIVE_ORDER, {it})) [also: oArray.sort(); oArray.sortBy{it.lowercase()}]
PHP: sort($oArray); usort($oArray, "strcasecmp"); [also: sort($oArray); sort($oArray, SORT_FLAG_CASE | SORT_STRING);]
Python: ___ [can use: oList.sort(); oList.sort(key=str.casefold)] [also: oList.sort(); oList.sort(key=str.lower)]
R: ___ [can use: oVec = sort(oVec, method="radix"); oVec = oVec[order(tolower(oVec))]]
Ruby: oArray.sort!; oArray.sort!(&:casecmp)
Rust: ___
Scala: ___ [can use: oArrayNew = oArray.sorted.sortWith(_.toLowerCase < _.toLowerCase)] [note: also works with lists]
Swift: oArray.sort(); oArray.sort{$0.caseInsensitiveCompare($1) == .orderedAscending} [requires: import Foundation]
UFL: Array.SortLocale [note: for code examples not specifying a locale, results depend on the current locale e.g. 'C', 'en_US.UTF-8', 'en_US', 'en'][WARNING: 'en_US.UTF-8' sorts case-insensitive, with a tiebreaker that (unusually) puts lower case then upper case, e.g. 'Q,q,w,W,E,e,r,R' to 'e,E,q,Q,r,R,w,W']
AutoHotkey: ___ [note: Sort can sort a string by a delimiter char] [note: can use (CL for locale, but differs from LC_COLLATE): Sort(vText, "D" vSep " CL")] [note: can use DllCall with msvcrt\_wsetlocale (or msvcrt\setlocale) to get/set the locale, but this doesn't affect Sort()]
C++: ___
C#: Array.Sort(oArray) [also: Array.Sort(oArray, Comparer.DefaultInvariant)] [requires (Comparer): using System.Collections] [e.g. set locale: System.Globalization.CultureInfo.CurrentCulture = new CultureInfo(vLocale, false)] [e.g. get locale, can use (also: .Name): vName = System.Globalization.CultureInfo.CurrentCulture.TwoLetterISOLanguageName]
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: Collections.sort(oList, oColl) [beforehand: e.g. oColl = Collator.getInstance(new Locale("en", "US")] [beforehand: e.g. oColl = Collator.getInstance()] [requires (Collator): import java.text.*]
JavaScript: oArray.sort(new Intl.Collator(vLocale).compare)
Kotlin: oArray.sortWith(compareBy(oColl){it}) [beforehand: e.g. oColl = java.text.Collator.getInstance(java.util.Locale("en", "US"))] [beforehand: e.g. oColl = java.text.Collator.getInstance()]
PHP: sort($oArray, SORT_LOCALE_STRING) [e.g. set locale: setlocale(LC_COLLATE, $vLocale)] [e.g. get locale: $vLocale = setlocale(LC_COLLATE, 0)]
Python: oList.sort(key=locale.strxfrm) [requires: import locale] [e.g. set locale: locale.setlocale(locale.LC_COLLATE, vLocale)] [e.g. get locale: vLocale = locale.getlocale(locale.LC_COLLATE)]
R: oVec = sort(oVec) [e.g. set locale: Sys.setlocale("LC_COLLATE", vLocale)] [e.g. get locale: vLocale = Sys.getlocale("LC_COLLATE")]
Ruby: ___
Rust: ___
Scala: ___ [can use: var oList = java.util.Arrays.stream(oArray).collect(java.util.stream.Collectors.toList()); java.util.Collections.sort(oList, oColl); oArray = oList.toArray().map(v=>v.toString);] [beforehand: e.g. oColl = java.text.Collator.getInstance(java.util.Locale("en", "US"))] [beforehand: e.g. oColl = java.text.Collator.getInstance()]
Swift: oArray.sort{$0.localizedCompare($1) == .orderedAscending}] [requires: import Foundation] [e.g. get locale, can use: Locale.current.languageCode]
UFL: Array.SortNatural [or Array.SortLogical][natural sort order][e.g. ["a1","a11","A2","a22"] to ["a1","A2","a11","a22"]]
AutoHotkey: ___ [note: Sort can sort a string by a delimiter char] [note: to sort logically: use mode 'CLogical' e.g. vText := Sort(vText, "D" vSep " CLogical")] [note: uses the Winapi's StrCmpLogicalW internally] [note: case-insensitive]
C++: ___
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: oArray.sort(new Intl.Collator(undefined, {numeric:true, sensitivity:"base"}).compare) [note: case-insensitive]
Kotlin: ___
PHP: natsort($oArray) [WARNING: case-sensitive]
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: ___
Swift: oArray.sort{(v1,v2) in v1.localizedStandardCompare(v2) == .orderedAscending} [requires: import Foundation] [note: case-insensitive]
UFL: Array.SortStrAsInt [e.g. ["1","11","111","2","22","222"] to ["1","2","11","22","111","222"]] [e.g. treat non-numbers as 0]
AutoHotkey: ___ [note: Sort can sort a string by a delimiter char] [note: to sort numerically: use mode 'N' e.g. vText := Sort(vText, "D" vSep " N")]
C++: ___
C#: Array.Sort(oArray, (v1,v2)=>Int32.Parse(v1).CompareTo(Int32.Parse(v2)))
Crystal: oArray.sort!{|v1,v2| v1.to_i <=> v2.to_i}
Excel: ___
Excel VBA: ___
Go: ___
Java: Arrays.sort(oArray, (v1,v2)->Integer.compare(Integer.parseInt(v1),Integer.parseInt(v2))) [requires: import java.util.*]
JavaScript: oArray.sort((v1,v2)=>parseInt(v1)-parseInt(v2)) [also: oArray.sort((v1,v2)=>v1-v2)]
Kotlin: oArray.sortWith{v1,v2->compareValues(v1.toInt(),v2.toInt())}
PHP: usort($oArray, fn($v1,$v2)=>intval($v1)<=>intval($v2)) [also: sort($oArray, SORT_NUMERIC)]
Python: oList.sort(key=int)
R: ___ [can use: oVec = oVec[order(as.integer(oVec))]]
Ruby: oArray.sort!{|v1,v2| v1.to_i <=> v2.to_i}
Rust: oArray.sort_by(|v1,v2| v1.parse::<i32>().unwrap().cmp(&v2.parse::<i32>().unwrap())) [note: also works with vectors]
Scala: ___ [can use: oArrayNew = oArray.sortWith(_.toInt < _.toInt)]
Swift: oArray.sort{Int($0)! <= Int($1)!}
UFL: Array.SortStrAsFloat [or Array.SortStrAsNum] [e.g. ["1","11","111","2","22","222"] to ["1","2","11","22","111","222"]] [e.g. treat non-numbers as 0]
AutoHotkey: ___ [note: Sort can sort a string by a delimiter char] [note: to sort numerically: use mode 'N' e.g. vText := Sort(vText, "D" vSep " N")]
C++: ___
C#: Array.Sort(oArray, (v1,v2)=>Double.Parse(v1).CompareTo(Double.Parse(v2)))
Crystal: oArray.sort!{|v1,v2| v1.to_f <=> v2.to_f}
Excel: ___
Excel VBA: ___
Go: ___
Java: Arrays.sort(oArray, (v1,v2)->Double.compare(Double.parseDouble(v1),Double.parseDouble(v2))) [requires: import java.util.*]
JavaScript: oArray.sort((v1,v2)=>v1-v2) [also: oArray.sort((v1,v2)=>parseFloat(v1)-parseFloat(v2))]
Kotlin: oArray.sortWith{v1,v2->compareValues(v1.toDouble(),v2.toDouble())}
PHP: sort($oArray, SORT_NUMERIC) [also: usort($oArray, fn($v1,$v2)=>floatval($v1)<=>floatval($v2))]
Python: oList.sort(key=float)
R: ___ [can use: oVec = oVec[order(as.numeric(oVec))]]
Ruby: oArray.sort!{|v1,v2| v1.to_f <=> v2.to_f}
Rust: oArray.sort_by(|v1,v2| v1.parse::<f64>().unwrap().partial_cmp(&v2.parse::<f64>().unwrap()).unwrap()) [note: also works with vectors]
Scala: ___ [can use: oArrayNew = oArray.sortWith(_.toDouble < _.toDouble)]
Swift: oArray.sort{Double($0)! <= Double($1)!}
UFL: Array.SortNumAsStr [e.g. [1,2,11,22,111,222] to [1,11,111,2,22,222]]
AutoHotkey: ___ [note: Sort can sort a string by a delimiter char] [note: to sort numerically: use mode 'N' e.g. vText := Sort(vText, "D" vSep " N")]
C++: ___
C#: Array.Sort(oArray, (v1,v2)=>v1.ToString().CompareTo(v2.ToString()))
Crystal: oArray.sort!{|v1,v2| v1.to_s <=> v2.to_s}
Excel: ___
Excel VBA: ___
Go: slices.SortFunc(oSlice, func(v1, v2 int) int { return cmp.Compare(fmt.Sprintf("%v", v1), fmt.Sprintf("%v", v2)) }) [also: slices.SortStableFunc()]
Java: oArray = Arrays.stream(oArray).boxed().sorted((v1,v2)->String.valueOf(v1).compareTo(String.valueOf(v2))).mapToInt(v->v).toArray() [requires: import java.util.*]
JavaScript: oArray.sort() [WARNING: default sort is alphabetical]
Kotlin: oArray.sortWith{v1,v2->compareValues(v1.toString(),v2.toString())}
PHP: sort($oArray, SORT_STRING) [also: usort($oArray, fn($v1,$v2)=>substr_compare($v1, $v2, 0, null, true))]
Python: oList.sort(key=str)
R: ___ [can use: oVec = oVec[order(as.character(oVec))]]
Ruby: oArray.sort!{|v1,v2| v1.to_s <=> v2.to_s}
Rust: oArray.sort_by(|v1,v2| v1.to_string().cmp(&v2.to_string())) [note: also works with vectors]
Scala: ___ [can use: oArrayNew = oArray.sortWith(_.toString < _.toString)
Swift: oArray.sort{String($0) <= String($1)}
UFL: Array.Sorted [note: doesn't modify the array (creates a new array)][note: methods ending 'ed' often return a new array, whereas other methods often modify an array]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: oArrayNew = oArray.sort
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [e.g. String[] oArrayNew = Arrays.stream(oArray).sorted().toArray(String[]::new)] [e.g. int[] oArrayNew = Arrays.stream(oArray).sorted().toArray()] [requires: import java.util.*]
JavaScript: oArrayNew = oArray.toSorted()
Kotlin: oArrayNew = oArray.sorted() [also: oArray.sortedWith(oFunc)]
PHP: ___
Python: oListNew = sorted(oList)
R: oVecNew = sort(oVec)
Ruby: oArrayNew = oArray.sort
Rust: ___
Scala: oArrayNew = oArray.sorted
Swift: oArrayNew = oArray.sorted()
UFL: Array.Reverse [note: modifies the array][see also: Array.Sort]
AutoHotkey: ___
C++: std::reverse(std::begin(oArray), std::end(oArray)) [also: std::reverse(oVec.begin(), oVec.end())] [requires (reverse): #include <algorithm>]
C#: Array.Reverse(oArray)
Crystal: oArray.reverse!
Excel: ___
Excel VBA: ___
Go: slices.Reverse(oSlice)
Java: Collections.reverse(oList) [requires: import java.util.*] [also (reverse int[]): oArrayNew = IntStream.range(0, oArray.length).map(i->oArray[oArray.length-1-i]).toArray()] [also (reverse double[]): oArrayNew = IntStream.range(0, oArray.length).mapToDouble(i->oArray[oArray.length-1-i]).toArray()] [also (reverse String[]/Integer[]): creates a temporary list, and reverses the array: Collections.reverse(Arrays.asList(oArray))] [requires (IntStream): import java.util.stream.*]
JavaScript: oArray.reverse()
Kotlin: oArray.reverse()
PHP: ___ [can use: $oArray = array_reverse($oArray)] [WARNING: array_reverse() creates a new array, it doesn't modify the existing array]
Python: oList.reverse() [also: oList = oList[::-1]]
R: ___ [can use: oVec = rev(oVec)] [WARNING: rev() creates a new vector, it doesn't modify the existing vector]
Ruby: oArray.reverse!
Rust: oArray.reverse() [also: oVec.reverse()]
Scala: ___ [can use: oArray = oArray.reverse] [note: also works with lists]
Swift: oArray.reverse()
UFL: Array.Reversed [note: doesn't modify the array (creates a new array)]
AutoHotkey: ___
C++: ___
C#: ___ [can use: oArrayNew = Enumerable.Range(1, oArray.Length).Select(i=>oArray[oArray.Length-i]).ToArray()] [also: oArrayNew = oArray.Select((v,k)=>new{k,v}).OrderByDescending(e=>e.k).Select(e=>e.v).ToArray()]
Crystal: oArrayNew = oArray.reverse
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: oArrayNew = oArray.toReversed() [also: oArrayNew = oArray.slice().reverse()]
Kotlin: oArrayNew = oArray.reversed()
PHP: $oArrayNew = array_reverse($oArray) [WARNING: array_reverse() creates a new array, it doesn't modify the existing array]
Python: oListNew = list(reversed(oList)) [also: oListNew = oList[::-1]]
R: oVecNew = rev(oVec) [WARNING: rev() creates a new vector, it doesn't modify the existing vector]
Ruby: oArrayNew = oArray.reverse
Rust: oVecNew = oArray.clone().into_iter().rev().collect::<Vec<_>>() [note: also works with vectors]
Scala: oArrayNew = oArray.reverse [note: also works with lists]
Swift: oArrayNew = Array(oArray.reversed())
UFL: Array.Shuffle [or Array.SortRandom][note: modifies the array][see also: Array.Sort]
AutoHotkey: ___
C++: std::shuffle(std::begin(oArray), std::end(oArray), oGen) [also: std::shuffle(oVec.begin(), oVec.end(), oGen)] [beforehand: std::random_device oRD; std::mt19937 oGen(oRD())] [deprecated: std::random_shuffle] [requires (shuffle): #include <algorithm>]
C#: ___
Crystal: oArray.shuffle!
Excel: ___
Excel VBA: ___
Go: rand.Shuffle(len(oArray), func(v1, v2 int) { oArray[v1], oArray[v2] = oArray[v2], oArray[v1] }) [beforehand: rand.Seed(time.Now().UnixNano())]
Java: Collections.shuffle(oList) [requires: import java.util.*] [WARNING: e.g. for String[]/Integer[] (but not int[]), 'Collections.shuffle(Arrays.asList(oArray))' creates a temporary list, and shuffles the array]
JavaScript: ___
Kotlin: oArray.shuffle()
PHP: shuffle($oArray)
Python: ___
R: ___ [can use: oVec = sample(oVec)] [also: set.seed()]
Ruby: oArray.shuffle!
Rust: oArray.shuffle(&mut thread_rng()) [requires: use rand::thread_rng] [requires: use rand::seq::SliceRandom] [note: also works with vectors]
Scala: ___ [can use: oArray = scala.util.Random.shuffle(oArray).toArray] [note: also works with lists]
Swift: oArray.shuffle()
UFL: (Array.Shuffled) [note: doesn't modify the array (creates a new array)]
AutoHotkey: ___
C++: ___
C#: var oArrayNew = oArray.OrderBy(v=>oRand.Next()).ToArray() [beforehand: var oRand = new Random()]
Crystal: oArrayNew = oArray.shuffle
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: oVecNew = sample(oVec) [also: set.seed()]
Ruby: oArrayNew = oArray.shuffle
Rust: ___
Scala: oArrayNew = scala.util.Random.shuffle(oArray).toArray [note: also works with lists]
Swift: oArrayNew = oArray.shuffled()
UFL: Array.Distinct [or Array.Unique/Array.Dedup/Array.RemoveDups/Array.RemoveDuplicates][remove duplicates, preserve order]
AutoHotkey: ___
C++: ___ [can use: for (const auto& vValue : oArray) if (!oMap.count(vValue)) oMap[vValue] = 1, oVecNew.push_back(vValue)] [beforehand (map): std::map<std::string,int> oMap] [beforehand (map/set): std::vector<std::string> oVecNew] [WARNING: std::unique only removes adjacent duplicates] [also (using set): for (const auto& vValue : oArray) if (!oSet.count(vValue)) oSet.insert(vValue), oVecNew.push_back(vValue)] [beforehand (set): std::unordered_set<std::string> oSet] [requires (set): #include <unordered_set>]
C#: var oArrayNew = oArray.Distinct().ToArray()
Crystal: oArrayNew = oArray.uniq [also (modifies array): oArray.uniq!]
Excel: ___
Excel VBA: ___
Go: ___ [can use (doesn't preserve order): oSliceNew := slices.Clone(oSlice); slices.Sort(oSliceNew); oSliceNew = slices.Compact(oSliceNew)] [note: slices.Compact removes consecutive duplicates]
Java: ___ [e.g. String[] oArrayNew = Arrays.stream(oArray).distinct().toArray(String[]::new)] [e.g. int[] oArrayNew = Arrays.stream(oArray).distinct().toArray()] [e.g. List<Integer>/List<String>: var oListNew = oList.stream().distinct().collect(Collectors.toList())] [note (all): preserves order] [requires (Collectors): import java.util.stream.*]
JavaScript: oArrayNew = [...new Set(oArray)] [note: preserves order]
Kotlin: oArrayNew = oArray.distinct() [also: oArray.distinctBy()] [note: preserves order]
PHP: $oArrayNew = array_values(array_unique($oArray)) [WARNING: array_unique() creates a new array, it doesn't modify the existing array] [WARNING: array_unique() maintains indexes, use array_values() to reindex an array] [note: preserves order]
Python: oListNew = list(dict.fromkeys(oList)) [note: preserves order]
R: oVecNew = unique(oVec) [note: preserves order]
Ruby: oArrayNew = oArray.uniq [also (modifies array): oArray.uniq!]
Rust: oVecNew: Vec<_> = oVec.into_iter().unique().collect() [requires (unique): use itertools::Itertools] [WARNING: dedup() only removes adjacent duplicates]
Scala: oArrayNew = oArray.distinct [note: preserves order] [note: also works with lists]
Swift: ___ [can use: oArrayNew = oArray.reduce(into:[]){$0.contains($1) ?():$0.append($1)}] [note: preserves order] [also (doesn't preserve order): oArrayNew = Array(Set(oArray))]
UFL: Array.FreqCount [or Array.FrequencyCount][return a map/dictionary][frequency table, preserve order]
AutoHotkey: ___
C++: ___ [can use: for (const auto& vValue : oArray) oMap[vValue]++] [also: for (const auto& vValue : oArray) oMap[vValue] = oMap.count(vValue) ? oMap[vValue]+1 : 1] [beforehand: std::map<std::string,int> oMap] [WARNING: if vKey doesn't exist, 'oMap[vKey]++' creates a key with the default value, e.g. 0, then increments it]
C#: ___ [e.g. int array: var oDict = oArray.GroupBy(v=>v).Select(g=>new[]{g.Key,g.Count()}).ToDictionary(e=>e[0], e=>e[1])] [e.g. string array: var oDict = oArray.GroupBy(v=>v).Select(g=>new KeyValuePair<string,int>(g.Key,g.Count())).ToDictionary(e=>e.Key, e=>e.Value)]
Crystal: ___ [can use: oMap = oArray.each_with_object(Hash(String,Int32).new(0)){|v,o| o[v]+=1}] [note: Hash(String,Int32).new(0) creates a map with default value 0]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [e.g. Map<String,Long> oMap = Arrays.stream(oArray).collect(Collectors.groupingBy(e->e, LinkedHashMap::new, Collectors.counting()))] [e.g. Map<Integer,Long> oMap = Arrays.stream(oArray).boxed().collect(Collectors.groupingBy(e->e, LinkedHashMap::new, Collectors.counting()))] [e.g. List<Integer>/List<String>: var oMap = oList.stream().collect(Collectors.groupingBy(e->e, LinkedHashMap::new, Collectors.counting()))] [note (all): preserves order] [requires (Collectors): import java.util.stream.*]
JavaScript: ___ [can use: for (const vValue of oArray) oMap.set(vValue, (oMap.get(vValue)||0) + 1)] [beforehand: oMap = new Map()] [note: preserves order]
Kotlin: oMap = oArray.toList().groupingBy{it}.eachCount() [note: preserves order]
PHP: $oMap = array_count_values($oArray) [note: preserves order]
Python: ___ [can use: for vValue in oList: oDict[vValue] = oDict.get(vValue, 0) + 1] [beforehand: oDict = dict()] [note: preserves order] [note: collections.Counter() doesn't preserve order]
R: table [e.g. oTable = table(oVec)] [note: oKeys = names(oTable)] [note: oValues = unname(oTable)] [WARNING: doesn't preserve order] [WARNING: stores items as strings (and counts as ints)]
Ruby: ___ [can use: oMap = oArray.each_with_object(Hash.new(0)){|v,o| o[v]+=1}] [note: Hash.new(0) creates a map with default value 0]
Rust: ___ [can use: oMap = oArray.into_iter().fold(BTreeMap::new(), |mut a,v| {a.entry(v).and_modify(|c| *c+=1).or_insert(1); a})] [note: also works with vectors] [requires: use std::collections::BTreeMap] [note: copied(), clone() also works]
Scala: ___ [can use: oMap = oArray.groupBy(identity).view.mapValues(_.size).toMap] [note: also works with lists] [WARNING (all): groupBy doesn't preserve order] [e.g. preserve order: var oMap = scala.collection.mutable.LinkedHashMap[String,Int](); oArray.foreach(v=>oMap(oFunc(v))=oMap.getOrElse(oFunc(v), 0)+1)]
Swift: ___ [can use: oDict = oArray.reduce(into:[:]){$0[$1,default:0]+=1}] [WARNING: doesn't preserve order]
UFL: Array.Max [see also: Max][comparing values according to the array's type, else numerically, return the max][WARNING: if an array is empty, max typically throws]
AutoHotkey: vMax := Max(oArray*) [note: throws if empty array]
C++: auto vMax = *std::max_element(std::begin(oArray), std::end(oArray)) [also: auto vMax = *std::max_element(oVec.begin(), oVec.end())] [note: std::begin throws if empty array] [WARNING: reads whatever is it at address if empty vector] [requires (max_element): #include <algorithm>]
C#: vMax = oArray.Max() [note: throws if empty array]
Crystal: vMax = oArray.max [note: throws if empty array]
Excel: ___ [can use: MAX()]
Excel VBA: vMax = WorksheetFunction.Max(oArray) [note: throws if empty array]
Go: vMax := slices.Max(oSlice) [note: throws if empty array]
Java: ___ [e.g. int[]: int vMax = Arrays.stream(oArray).max().getAsInt()] [e.g. String[]: var vMax = Arrays.stream(oArray).sorted().skip(oArray.length-1).findFirst().get()] [e.g. List<Integer>/List<String>: var vMax = Collections.max(oList)] [e.g. int[]: int vMax = Arrays.stream(oArray).summaryStatistics().getMax()] [note: max() throws if empty array]
JavaScript: vMax = Math.max(...oArray) [note: returns -Infinity if empty array]
Kotlin: vMax = oArray.max() [note: throws if empty array] [also: oMaxOpt = oArray.maxOrNull()]
PHP: $vMax = max($oArray) [note: 'standard comparison rules' e.g. 'a non-numeric string will be compared to an int as though it were 0']
Python: vMax = max(oList) [note: throws if empty array]
R: vMax = max(oVec) [note: returns -Inf if empty array]
Ruby: vMax = oArray.max [note: returns nil if empty array]
Rust: vMax = oArray.iter().max().unwrap() [note: also works with vectors]
Scala: vMax = oArray.max [note: max() throws if empty array] [note: also works with lists]
Swift: vMax = oArray.max()! [note: returns nil if empty array]
UFL: Array.Min [see also: Min][comparing values according to the array's type, else numerically, return the min][WARNING: if an array is empty, min typically throws]
AutoHotkey: vMin := Min(oArray*) [note: throws if empty array]
C++: auto vMin = *std::min_element(std::begin(oArray), std::end(oArray)) [also: auto vMin = *std::min_element(oVec.begin(), oVec.end())] [note: std::begin throws if empty array] [WARNING: reads whatever is it at address if empty vector] [requires (min_element): #include <algorithm>]
C#: vMin = oArray.Min() [note: throws if empty array]
Crystal: vMin = oArray.min [note: throws if empty array]
Excel: ___ [can use: MIN()]
Excel VBA: vMin = WorksheetFunction.Min(oArray) [note: throws if empty array]
Go: vMin := slices.Min(oSlice) [note: throws if empty array]
Java: ___ [e.g. int[]: int vMin = Arrays.stream(oArray).min().getAsInt()] [e.g. String[]: var vMin = Arrays.stream(oArray).sorted().findFirst().get()] [e.g. List<Integer>/List<String>: var vMin = Collections.min(oList)] [e.g. int[]: int vMin = Arrays.stream(oArray).summaryStatistics().getMin()] [note: min() throws if empty array]
JavaScript: vMin = Math.min(...oArray) [note: returns Infinity if empty array]
Kotlin: vMin = oArray.min() [note: throws if empty array] [also: oMinOpt = oArray.minOrNull()]
PHP: $vMin = min($oArray) [note: 'standard comparison rules' e.g. 'a non-numeric string will be compared to an int as though it were 0']
Python: vMin = min(oList) [note: throws if empty array]
R: vMin = min(oVec) [note: returns Inf if empty array]
Ruby: vMin = oArray.min [note: returns nil if empty array]
Rust: vMin = oArray.iter().min().unwrap() [note: also works with vectors]
Scala: vMin = oArray.min [note: min() throws if empty array] [note: also works with lists]
Swift: vMin = oArray.min()! [note: returns nil if empty array]
UFL: (Array.StrMax) [comparing values as strings, return the max][see also: Array.ToStrArray]
AutoHotkey: ___
C++: auto vMax = *std::max_element(std::begin(oArray), std::end(oArray)) [also: auto vMax = *std::max_element(oVec.begin(), oVec.end())] [requires (max_element): #include <algorithm>]
C#: vMax = oArray.Select(v=>v.ToString()).Max() [also (if all values strings): var vMax = oArray.Max()] [requires: using System.Linq]
Crystal: vMax = oArray.map(&.to_s).max
Excel: ___
Excel VBA: ___
Go: ___ [e.g. []string: vMax := slices.Max(oSlice)]
Java: ___ [e.g. String[]: var vMax = Arrays.stream(oArray).sorted().skip(oArray.length-1).findFirst().get()] [e.g. List<String>: var vMax = Collections.max(oList)]
JavaScript: vMax = oArray.toSorted().pop()
Kotlin: vMax = oArray.map{v->v.toString()}.max() [also (if all values strings): vMax = oArray.max()] [also: oArray.maxOrNull()]
PHP: $vMax = array_reduce($oArray, function($vText1, $vText2) {return (($vText1 == null) ? $vText2 : (strcmp($vText1, $vText2) >= 0 ? $vText1 : $vText2));}) [also (if all values strings): $vMax = max($oArray)]
Python: vMax = max(map(str, oList)) [also (if all values strings): vMax = max(oList)]
R: vMax = tail(oVec[order(as.character(oVec))], 1) [note: returns NULL if empty]
Ruby: vMax = oArray.map(&:to_s).max
Rust: vMax = oArray.iter().map(|v| (*v).to_string()).max().unwrap() [note: also works with vectors]
Scala: vMax = oArray.map(_.toString).max [note: also works with lists]
Swift: vMax = oArray.map{String($0)}.max()! [also (if all values strings): vMax = oArray.max()!]
UFL: (Array.StrMin) [comparing values as strings, return the min][see also: Array.ToStrArray]
AutoHotkey: ___
C++: auto vMin = *std::min_element(std::begin(oArray), std::end(oArray)) [also: auto vMin = *std::min_element(oVec.begin(), oVec.end())] [requires (min_element): #include <algorithm>]
C#: vMin = oArray.Select(v=>v.ToString()).Min() [also (if all values strings): var vMin = oArray.Min()] [requires: using System.Linq]
Crystal: vMin = oArray.map(&.to_s).min
Excel: ___
Excel VBA: ___
Go: ___ [e.g. []string: vMin := slices.Min(oSlice)]
Java: ___ [e.g. String[]: var vMin = Arrays.stream(oArray).sorted().findFirst().get()] [e.g. List<String>: var vMin = Collections.min(oList)]
JavaScript: vMin = oArray.toSorted()[0]
Kotlin: vMin = oArray.map{v->v.toString()}.min() [also (if all values strings): vMin = oArray.min()] [also: oArray.minOrNull()]
PHP: $vMin = array_reduce($oArray, function($vText1, $vText2) {return (($vText1 == null) ? $vText2 : (strcmp($vText1, $vText2) <= 0 ? $vText1 : $vText2));}) [also (if all values strings): $vMin = min($oArray)]
Python: vMin = min(map(str, oList)) [also (if all values strings): vMin = min(oList)]
R: vMin = head(oVec[order(as.character(oVec))], 1) [also: vMin = oVec[order(as.character(oVec))][1]] [note (both): returns NULL if empty]
Ruby: vMin = oArray.map(&:to_s).min
Rust: vMin = oArray.iter().map(|v| (*v).to_string()).min().unwrap() [note: also works with vectors]
Scala: vMin = oArray.map(_.toString).min [note: also works with lists]
Swift: vMin = oArray.map{String($0)}.min()! [also (if all values strings): vMin = oArray.min()!]
UFL: Array.Sum [see also: Sum]
AutoHotkey: ___
C++: int vSum = std::accumulate(std::begin(oArray), std::end(oArray), 0) [requires (accumulate): #include <numeric>]
C#: vSum = oArray.Sum() [requires: using System.Linq]
Crystal: vSum = oArray.sum [also: vSum = oRange.sum]
Excel: ___ [can use: SUM()]
Excel VBA: vSum = WorksheetFunction.Sum(oArray)
Go: ___
Java: vSum = Arrays.stream(oArray).sum() [requires: import java.util.*]
JavaScript: vSum = oArray.reduce((a,v)=>a+v)
Kotlin: vSum = oArray.sum()
PHP: $vSum = array_sum($oArray)
Python: vSum = sum(oList)
R: vSum = sum(oVec)
Ruby: vSum = oArray.sum [also: vSum = oRange.sum]
Rust: vSum: i32 = oArray.iter().sum()
Scala: vSum = oArray.sum
Swift: vSum = oArray.reduce(0, +)
UFL: Array.Product [see also: Product]
AutoHotkey: ___
C++: int vProduct = std::accumulate(std::begin(oArray), std::end(oArray), 1, std::multiplies<int>()) [requires (accumulate): #include <numeric>]
C#: vProduct = oArray.Aggregate(1, (a,v)=>a*v) [requires: using System.Linq]
Crystal: vProduct = oArray.product
Excel: ___ [can use: PRODUCT()]
Excel VBA: vProduct = WorksheetFunction.Product(oArray)
Go: ___
Java: vProduct = Arrays.stream(oArray).reduce(1, (a,v)->a*v) [requires: import java.util.*]
JavaScript: vProduct = oArray.reduce((a,v)=>a*v)
Kotlin: vProduct = oArray.reduce(Int::times)
PHP: $vProduct = array_product($oArray)
Python: vProduct = math.prod(oList) [requires: import math]
R: vProduct = prod(oVec)
Ruby: vProduct = oArray.reduce{|a,v| a*v}
Rust: vProduct: i32 = oArray.iter().product()
Scala: vProduct = oArray.product
Swift: vProduct = oArray.reduce(1, *)
UFL: Array.Mean [see also: Mean/Array.Sum]
AutoHotkey: ___
C++: double vMean = (double)std::accumulate(std::begin(oArray), std::end(oArray), 0) / (sizeof(oArray)/sizeof(oArray[0])) [requires (accumulate): #include <numeric>]
C#: vMean = oArray.Average() [requires: using System.Linq]
Crystal: vMean = oArray.sum / oArray.size
Excel: ___ [can use: AVERAGE()]
Excel VBA: vMean = WorksheetFunction.Average(oArray)
Go: ___
Java: vMean = Arrays.stream(oArray).average().orElseThrow() [note: orElseThrow() to unwrap optional value] [also: double vMean = Arrays.stream(oArray).summaryStatistics().getAverage()] [requires: import java.util.*]
JavaScript: vMean = oArray.reduce((a,v)=>a+v) / oArray.length
Kotlin: vMean = oArray.average()
PHP: $vMean = array_sum($oArray) / count($oArray)
Python: vMean = statistics.mean(oList)
R: vMean = mean(oVec)
Ruby: vMean = oArray.sum / oArray.length.to_f
Rust: vMean = oArray.iter().sum::<i32>() as f32 / oArray.len() as f32
Scala: vMean = oArray.sum/oArray.length.toDouble
Swift: vMean = oArray.reduce(0, +) / oArray.count
UFL: Array.Median [see also: Median/Array.Sort]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___
Excel: ___ [can use: MEDIAN()]
Excel VBA: vMedian = WorksheetFunction.Median(oArray)
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: vMedian = statistics.median(oList) [requires: import statistics]
R: vMedian = median(oVec)
Ruby: ___
Rust: ___
Scala: ___
Swift: ___
UFL: Array.Mode [or Array.Modes][see also: Mode/Array.FreqCount][return an array containing the mode(s)][note: if all elements appear once, could either return all elements or throw]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___
Excel: ___ [can use: MODE.MULT()] [WARNING: MODE: returns the first mode, and fails if the first mode has frequency 1]
Excel VBA: ___ [can use: WorksheetFunction.Mode_Mult()] [WARNING: WorksheetFunction.Mode: requires an array, returns the first mode, and fails if the first mode has frequency 1]
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: oMode = statistics.multimode(oList) [requires: import statistics]
R: ___ [WARNING: mode() returns the variable's 'mode', somewhat like typeof()/class()] [can use: modes, any type, excludes NAs: oVecNew = names(table(oVec))[table(oVec)==max(table(oVec))]] [also: modes, ints only, includes NAs: oUnique = unique(oVec); oTable = tabulate(match(oVec, oUnique)); oVecNew = oUnique[oTable == max(oTable)]] [also: one mode only, any type, excludes NAs: vMode = names(which.max(table(oVec)))]
Ruby: ___
Rust: ___
Scala: ___
Swift: ___
UFL: Array.Equals [or Array.Match][do the contents of 2 arrays match (same items, same order, same item frequency)]
AutoHotkey: ___
C++: auto vIsMatch = std::equal(std::begin(oArray1), std::end(oArray1), std::begin(oArray2)) [also: auto vIsMatch = std::equal(oVec1.begin(), oVec1.end(), oVec2.begin())] [requires (equal): #include <algorithm>]
C#: bool vIsMatch = Enumerable.SequenceEqual(oArray1, oArray2) [also: bool vIsMatch = oArray1.SequenceEqual(oArray2)]
Crystal: vIsMatch = (oArray1 == oArray2)
Excel: ___
Excel VBA: ___
Go: vIsMatch := slices.Equal(oSlice1, oSlice2)
Java: vIsMatch = Arrays.equals(oArray1, oArray2) [e.g. works on int[]/String[]]
JavaScript: ___ [can use: vIsMatch = (oArray1.length == oArray2.length) && [...oArray1.keys()].every(k=>(k in oArray2) && (oArray1[k] === oArray2[k]))] [also: vIsMatch = (JSON.stringify(oArray1) == JSON.stringify(oArray2))]
Kotlin: vIsMatch = (oArray1 contentEquals oArray2)
PHP: $vIsMatch = ($oArray1 === $oArray2)
Python: ___
R: vIsMatch = identical(oVec1, oVec2)
Ruby: vIsMatch = (oArray1 == oArray2)
Rust: vIsMatch = (oArray1 == oArray2) [also: vIsMatch = oArray1.eq(&oArray2)] [note: also works with vectors] [note: array comparisons (== and eq) fail at compile time if array sizes differ]
Scala: vIsMatch = oArray1 sameElements oArray2
Swift: vIsMatch = (oArray1.count == oArray2.count) && (oArray1 == oArray2)
UFL: Array.EqualsIgnoreOrder [do the contents of 2 arrays match (same items, key order irrelevant, same item frequency)][note: arrays can contain items multiple times, sets only contain items once]
AutoHotkey: ___
C++: ___ [can use: std::string oArrayCopy1[123]; std::string oArrayCopy2[123]; std::copy(std::begin(oArray1), std::end(oArray1), std::begin(oArrayCopy1)); std::copy(std::begin(oArray2), std::end(oArray2), std::begin(oArrayCopy2)); std::sort(std::begin(oArrayCopy1), std::end(oArrayCopy1)); std::sort(std::begin(oArrayCopy2), std::end(oArrayCopy2)); auto vIsMatch = std::equal(std::begin(oArrayCopy1), std::end(oArrayCopy1), std::begin(oArrayCopy2))] [note: replace '123' with the necessary size] [requires (copy/equal/sort): #include <algorithm>]
C#: bool vIsMatch = Enumerable.SequenceEqual(oArray1.OrderBy(v=>v), oArray2.OrderBy(v=>v)) [also: bool vIsMatch = oArray1.OrderBy(v=>v).SequenceEqual(oArray2.OrderBy(v=>v))]
Crystal: vIsMatch = (oArray1.sort == oArray2.sort)
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use (e.g. int[]/String[]): var oArrayCopy1 = oArray1.clone(); var oArrayCopy2 = oArray2.clone(); Arrays.sort(oArrayCopy1); Arrays.sort(oArrayCopy2); var vIsMatch = Arrays.equals(oArrayCopy1, oArrayCopy2)]
JavaScript: ___
Kotlin: vIsMatch = (oArray1.sorted().toTypedArray() contentEquals oArray2.sorted().toTypedArray())
PHP: ___
Python: ___
R: vIsMatch = identical(sort(oVec1), sort(oVec2))
Ruby: vIsMatch = (oArray1.sort == oArray2.sort)
Rust: ___
Scala: vIsMatch = oArray1.sorted sameElements oArray2.sorted
Swift: vIsMatch = (oArray1.count == oArray2.count) && (oArray1.sorted() == oArray2.sorted())
UFL: Array.Map [see also: Array.ForEach/Array.MapDemoBlock/Array.MapWithIndexDemoBlock]
AutoHotkey: ___
C++: std::transform(std::begin(oArray), std::end(oArray), oArrayNew, oFunc) [also: std::transform(oVec.begin(), oVec.end(), std::back_inserter(oVecNew), oFunc)] [requires (transform): #include <algorithm>]
C#: oArrayNew = oArray.Select(oFunc).ToArray() [also: oArrayNew = oArray.Select(v=>oFunc(v)).ToArray()]
Crystal: oArrayNew = oArray.map(&oFunc) [also: oArrayNew = oArray.map{|v| oFunc.call(v)}]
Excel: ___
Excel VBA: ___
Go: ___
Java: int[] oArrayNew = Arrays.stream(oArray).boxed().mapToInt(oFunc).toArray() [requires: import java.util.*] [also: map()] [also: int[][] oArrayNew = Arrays.stream(oArray).mapToObj(v->oFunc.apply(v)).toArray(int[][]::new)]
JavaScript: oArrayNew = oArray.map(oFunc) [also: oArrayNew = oArray.map(v=>oFunc(v))]
Kotlin: oArrayNew = oArray.map(oFunc).toTypedArray() [also: oArrayNew = oArray.map{oFunc(it)}.toTypedArray()]
PHP: $oArrayNew = array_map($oFunc, $oArray) [also: $oArrayNew = array_map(fn($v)=>$oFunc($v), $oArray)] [WARNING: param order: func then array, unlike reduce/filter] [also: array_walk()]
Python: oListNew = list(map(oFunc, oList)) [also: oListNew = list(map(lambda v:oFunc(v), oList))]
R: oVecNew = mapply(oFunc, oVec) [also: oVecNew = mapply(\(v) oFunc(v), oVec)] [also: oVecNew = unlist(Map(oFunc, oVec))] [WARNING: these are equivalent: oVecNew = oVec + 5, oVecNew = mapply(\(v) v+5, oVec)]
Ruby: oArrayNew = oArray.map(&oFunc) [also: oArrayNew = oArray.map{|v| oFunc.call(v)}]
Rust: oVecNew = oArray.iter().map(|v| oFunc(*v)).collect::<Vec<_>>() [note: also works with vectors] [also (array to array): oArrayNew = oArray.map(|v| oFunc(v))]
Scala: oArrayNew = oArray.map(oFunc) [also: oArrayNew = oArray.map(oFunc(_))] [also: oArrayNew = oArray.map(v=>oFunc(v))]
Swift: oArrayNew = oArray.map(oFunc) [also: oArrayNew = oArray.map{oFunc($0)}] [also: oArray.compactMap()] [deprecated: oArray.flatMap()]
UFL: Array.FlatMap [note: map appends function output to array, flatmap appends array items in function output to array][see also: Array.Flat/Array.Flattened]
AutoHotkey: ___
C++: ___
C#: oArrayNew = oArray.SelectMany(v=>oFunc(v)).ToArray() [also: oArrayNew = oArray.SelectMany(oFunc).ToArray()] [requires: using System.Linq]
Crystal: oArrayNew = oArray.flat_map{|v| oFunc.call(v)} [also: oArrayNew = oArray.flat_map(&oFunc)]
Excel: ___
Excel VBA: ___
Go: ___
Java: int[] oArrayNew = Arrays.stream(oArray).boxed().flatMapToInt(v->Arrays.stream(oFunc.apply(v))).toArray() [also: flatMap()]
JavaScript: oArrayNew = oArray.flatMap(v=>oFunc(v)) [also: oArrayNew = oArray.flatMap(oFunc)]
Kotlin: oArrayNew = oArray.flatMap{v->oFunc(v)}.toTypedArray() [also: oArrayNew = oArray.flatMap(oFunc).toTypedArray()]
PHP: ___ [can use: $oArrayNew = array_merge(...array_map(fn($v)=>$oFunc($v), $oArray))] [also: $oArrayNew = array_merge(...array_map($oFunc, $oArray))]
Python: ___ [can use: oListNew = [v2 for v1 in oList for v2 in oFunc(v1)]]
R: ___ [can use: oVecNew = c(mapply(oFunc, oVec))] [also: oVecNew = unlist(Map(oFunc, oVec))]
Ruby: oArrayNew = oArray.flat_map{|v| oFunc.call(v)}
Rust: oVecNew = oArray.iter().flat_map(|v| oFunc(*v)).collect::<Vec<_>>() [note: also works with vectors]
Scala: oArrayNew = oArray.flatMap(oFunc)
Swift: oArrayNew = oArray.flatMap{oFunc($0)} [also: oArrayNew = oArray.flatMap(oFunc)]
UFL: Array.Reduce [or Array.ReduceNoSeed][or Array.Fold/Array.ReduceLeft/Array.FoldLeft]['reduce left'/'fold left'][note: omit seed, use first value as seed][note: would typically throw or return null, if passed an empty array, and no seed][see also: Array.ReduceWithSeed/Array.ReduceDemoBlock/Array.ReduceWithIndexDemoBlock]
AutoHotkey: ___
C++: ___ [can use: int vRet = std::accumulate(std::begin(oArray)+1, std::end(oArray), oArray[0], oFunc)] [can use: int vRet = std::accumulate(oVec.begin()+1, oVec.end(), oVec[0], oFunc)] [WARNING: std::accumulate() requires a seed value, workaround: use the first array value as the seed, and pass the rest of the array as the array] [requires (accumulate): #include <numeric>] [also: std::reduce()] [also: std::ranges::fold_left()]
C#: vRet = oArray.Aggregate(oFunc) [also: vRet = oArray.Aggregate((a,v)=>oFunc(a,v))]
Crystal: vRet = oArray.reduce(&oFunc) [also: vRet = oArray.reduce{|a,v| oFunc.call(a,v)}]
Excel: ___
Excel VBA: ___
Go: ___
Java: int vRet = Arrays.stream(oArray).boxed().reduce(oFunc).orElseThrow() [requires: import java.util.*] [note: if array empty and no seed, would throw, so orElseThrow needed]
JavaScript: vRet = oArray.reduce(oFunc) [also: vRet = oArray.reduce((a,v)=>oFunc(a,v))] [note: throws if array empty and no seed]
Kotlin: vRet = oArray.reduce(oFunc) [also: vRet = oArray.reduce{a,v->oFunc(a,v)}] [note: throws if array empty and no seed] [note: in Kotlin, reduce doesn't let you specify a seed, fold does]
PHP: ___ [can use: $vRet = array_reduce(array_slice($oArray, 1), $oFunc, $oArray[0])] [also: $vRet = array_reduce(array_slice($oArray, 1), fn($a,$v)=>$oFunc($a,$v), $oArray[0])] [can use (if seed value of null doesn't affect result): $vRet = array_reduce($oArray, $oFunc)] [WARNING: if the seed (initial value) param is omitted, null is used as the seed, in most languages, if no seed is specified, the first array value is used as the seed, (e.g. sum is OK: null+3=3, concat is OK: null . "abc"="abc", product is not OK: it would be 0: null*3=0)] [note: if array empty and seed param omitted, null is returned]
Python: vRet = reduce(oFunc, oList) [also: vRet = reduce(lambda a,v:oFunc(a,v), oList)] [requires: from functools import reduce] [note: throws if array empty and no seed]
R: vRet = Reduce(oFunc, oVec) [also: vRet = Reduce(\(a,v) oFunc(a,v), oVec)]
Ruby: vRet = oArray.reduce(&oFunc) [also: vRet = oArray.reduce{|a,v| oFunc.call(a,v)}] [note: reduce is an alias of inject]
Rust: vRet = oArray.into_iter().reduce(|a,v| oFunc(a,v)).unwrap()
Scala: vRet = oArray.reduce(oFunc) [also: vRet = oArray.reduce((v1,v2)=>oFunc(v1,v2))] [also: reduceLeft]
Swift: ___ [can use: vRet = oArray.dropFirst().reduce(oArray[0], oFunc)] [also: vRet = oArray.dropFirst().reduce(oArray[0]){oFunc($0,$1)}] [WARNING: reduce() requires a seed value, workaround: use the first array value as the seed, and pass the rest of the array as the array]
UFL: Array.ReduceWithSeed [note: in some languages: 'fold' is with seed, 'reduce' is without seed][note: specify seed (init/identity)]
AutoHotkey: ___
C++: int vRet = std::accumulate(std::begin(oArray), std::end(oArray), vSeed, oFunc) [also: int vRet = std::accumulate(oVec.begin(), oVec.end(), vSeed, oFunc)] [requires (accumulate): #include <numeric>] [also: std::reduce()] [also: std::ranges::fold_left()]
C#: vRet = oArray.Aggregate(vSeed, oFunc)
Crystal: vRet = oArray.reduce(vSeed, &oFunc) [also: vRet = oArray.reduce(vSeed){|a,v| oFunc.call(a,v)}]
Excel: ___
Excel VBA: ___
Go: ___
Java: int vRet = Arrays.stream(oArray).boxed().reduce(vSeed, oFunc) [requires: import java.util.*] [note: a seed is specified, so guaranteed at least one value, orElseThrow not needed]
JavaScript: vRet = oArray.reduce(oFunc, vSeed)
Kotlin: vRet = oArray.fold(vSeed, oFunc)
PHP: $vRet = array_reduce($oArray, $oFunc, $vSeed)
Python: vRet = reduce(oFunc, oList, vSeed) [requires: from functools import reduce]
R: vRet = Reduce(oFunc, oVec, vSeed)
Ruby: vRet = oArray.reduce(vSeed, &oFunc) [also: vRet = oArray.reduce(vSeed){|a,v| oFunc.call(a,v)}] [note: reduce is an alias of inject]
Rust: vRet = oArray.iter().fold(vSeed, |a,v| oFunc(a,*v))
Scala: vRet = oArray.fold(vSeed)(oFunc) [also: vRet = oArray.fold(vSeed)((v1,v2)=>oFunc(v1,v2))] [also: foldLeft] [note: foldLeft is more permissive regarding which types it accepts]
Swift: vRet = oArray.reduce(vSeed, oFunc) [also: vRet = oArray.reduce(vSeed){oFunc($0,$1)}] [note: 'into' can make blocks simpler and more performant: with 'into' you can modify $0 directly each time (the seed/accumulator), without 'into', you have to clone $0, modify it, and return it each time] [e.g. 'into': to array: oArray.reduce(into:[]){$0.append($1+10)}] [e.g. 'into': to dictionary: oArray.reduce(into:[:]){$0[$1]=1}]
UFL: Array.ReduceRight [or Array.FoldRight]['reduce right'/'fold right' is equivalent to reduce left but with the array values reversed, and the 2-param function's param order reversed][see also: Array.Reverse/Array.Reversed/Array.Reduce]
AutoHotkey: ___
C++: ___ [can use: std::accumulate(), but it requires a seed value] [also: std::reduce()] [also: std::ranges::fold_right()]
C#: ___ [can use: vRet = oArrayRev.Aggregate((a,v)=>oFunc(v,a))]
Crystal: ___ [can use: vRet = oArrayRev.reduce{|a,v| oFunc.call(v,a)}]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use (e.g. int[]/double[]): Arrays.stream(oArrayRev).boxed().reduce((a,v)->oFunc.apply(v,a)).orElseThrow()]
JavaScript: ___ [can use: vRet = oArray.reduceRight((a,v)=>oFunc(v,a))] [WARNING: 'reduce right' is a misnomer, the method is equivalent to reversing the array and doing reduce left, for true reverse right, reverse the 2-param function's param order] [note: throws if array empty and no seed]
Kotlin: vRet = oArray.reduceRight(oFunc) [note: throws if array empty and no seed] [note: in Kotlin, reduce doesn't let you specify a seed, fold does]
PHP: ___ [can use (requires a seed): $vRet = array_reduce($oArrayRev, fn($a,$v)=>$oFunc($v,$a), $vSeed)]
Python: ___ [can use: vRet = reduce(lambda a,v:oFunc(v,a), oListRev)]
R: ___ [can use: vRet = Reduce(\(a,v) oFunc(v,a), oVecRev)]
Ruby: ___ [can use: vRet = oArrayRev.reduce{|a,v| oFunc.call(v,a)}]
Rust: ___ [can use: vRet = oArrayRev.into_iter().reduce(|a,v| oFunc(v,a)).unwrap()]
Scala: vRet = oArray.reduceRight(oFunc) [also: vRet = oArray.reduceRight((v1,v2)=>oFunc(v1,v2))]
Swift: ___ [can use (requires a seed): vRet = oArrayRev.reduce(vSeed){oFunc($1,$0)}]
UFL: Array.ReduceRightWithSeed [or Array.FoldRightWithSeed][see also: Array.Reverse/Array.Reversed/Array.ReduceWithSeed]
AutoHotkey: ___
C++: int vRet = std::accumulate(std::begin(oArrayRev), std::end(oArrayRev), vSeed, [oFunc](int a,int v){return oFunc(v,a);}) [also: int vRet = std::accumulate(oVecRev.begin(), oVecRev.end(), vSeed, [oFunc](int a,int v){return oFunc(v,a);})] [requires (accumulate): #include <numeric>] [also: std::reduce()] [also: std::ranges::fold_right()]
C#: ___ [can use: vRet = oArrayRev.Aggregate(vSeed, (a,v)=>oFunc(v,a))]
Crystal: ___ [can use: vRet = oArrayRev.reduce(vSeed){|a,v| oFunc.call(v,a)}]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use: int vRet = Arrays.stream(oArrayRev).boxed().reduce(vSeed, (a,v)->oFunc.apply(v,a))] [requires: import java.util.*] [note: a seed is specified, so guaranteed at least one value, orElseThrow not needed]
JavaScript: ___ [can use: vRet = oArray.reduceRight((a,v)=>oFunc(v,a), vSeed)] [WARNING: 'reduce right' is a misnomer, the method is equivalent to reversing the array and doing reduce left, for true reverse right, reverse the 2-param function's param order]
Kotlin: vRet = oArray.foldRight(vSeed, oFunc)
PHP: ___ [can use: $vRet = array_reduce($oArrayRev, fn($a,$v)=>$oFunc($v,$a), $vSeed)]
Python: ___ [can use: vRet = reduce(lambda a,v:oFunc(v,a), oListRev, vSeed)] [requires: from functools import reduce]
R: ___ [can use: vRet = Reduce(\(a,v) oFunc(v,a), oVecRev, vSeed)]
Ruby: ___ [can use: vRet = oArrayRev.reduce(vSeed){|a,v| oFunc.call(v,a)}]
Rust: ___ [can use: vRet = oArrayRev.iter().fold(vSeed, |a,v| oFunc(*v,a))]
Scala: vRet = oArray.foldRight(vSeed)(oFunc) [also: vRet = oArray.foldRight(vSeed)((v1,v2)=>oFunc(v1,v2))]
Swift: ___ [can use: vRet = oArrayRev.reduce(vSeed){oFunc($1,$0)}]
UFL: Array.Filter [create an array containing values that match predicate][see also: Array.Count/Array.GroupBy/Array.Partition/Array.Find/Array.FilterDemoBlock/Array.FilterWithIndexDemoBlock]
AutoHotkey: ___
C++: std::copy_if(oVec.begin(), oVec.end(), std::back_inserter(oVecNew), oFunc) [requires (copy_if/remove_if): #include <algorithm>] [also: std::remove_if(oVec.begin(), oVec.end(), oFunc)]
C#: oArrayNew = oArray.Where(oFunc).ToArray() [also: oArrayNew = oArray.Where(v=>oFunc(v)).ToArray()]
Crystal: oArrayNew = oArray.select(&oFunc) [also: oArrayNew = oArray.select{|v| oFunc.call(v)}]
Excel: ___
Excel VBA: ___ [note: can use Filter() to list matches(/non-matches) that are a *substring* of a needle, case-sensitive/case-insensitive (integer values are treated as strings)]
Go: ___
Java: int[] oArrayNew = Arrays.stream(oArray).boxed().filter(oFunc).mapToInt(v->v).toArray() [requires: import java.util.*]
JavaScript: oArrayNew = oArray.filter(oFunc) [also: oArrayNew = oArray.filter(v=>oFunc(v))]
Kotlin: oArrayNew = oArray.filter(oFunc).toTypedArray() [also: oArrayNew = oArray.filter{oFunc(it)}.toTypedArray()]
PHP: $oArrayNew = array_values(array_filter($oArray, $oFunc)) [also: $oArrayNew = array_values(array_filter($oArray, fn($v)=>$oFunc($v)))] [WARNING: array_filter() maintains indexes, use array_values() to reindex an array]
Python: oListNew = list(filter(oFunc, oList)) [also: oListNew = list(filter(lambda v:oFunc(v), oList))]
R: oVecNew = Filter(oFunc, oVec) [also: oVecNew = Filter(\(v) oFunc(v), oVec)] [also (unusual syntax): oVecNew = oVec[oFunc(oVec)]] [e.g. (unusual syntax): oVecNew = oVec[oVec%%3 == 0]] [note: Filter() excludes NA values]
Ruby: oArrayNew = oArray.select(&oFunc) [also: oArrayNew = oArray.select{|v| oFunc.call(v)}] [also (alias): filter]
Rust: oVecNew = oArray.iter().filter(|v| oFunc(**v)).collect::<Vec<_>>()
Scala: oArrayNew = oArray.filter(oFunc) [also: oArrayNew = oArray.filter(oFunc(_))] [also: oArrayNew = oArray.filter(v=>oFunc(v))]
Swift: oArrayNew = oArray.filter(oFunc) [also: oArrayNew = oArray.filter{oFunc($0)}]
UFL: Array.FilterGetEveryNth [get every nth key][e.g. get keys 4/8/12/16/20 (1-based), 3/7/11/15/19 (0-based)][see also: Range.NewWithStep/Array.GroupByWithIndex]
AutoHotkey: ___
C++: for (int i=0; i<oVec.size(); i++) if (i%vNum == vNum-1) oVecNew.push_back(oVec[i])
C#: oArrayNew = oArray.Where((v,k)=>(k%vNum == vNum-1)).ToArray()
Crystal: oArrayNew = oArray.each_with_index.select{|v,k| (k%vNum == vNum-1)}.map{|vk|vk[0]}.to_a
Excel: ___
Excel VBA: ___
Go: ___
Java: oArrayNew = IntStream.range(0, oArray.length).boxed().filter(i->(i%vNum == vNum-1)).mapToInt(i->oArray[i]).toArray()
JavaScript: oArrayNew = oArray.filter((v,k)=>(k%vNum == vNum-1))
Kotlin: oArrayNew = oArray.filterIndexed{k,_->(k%vNum == vNum-1)}.toTypedArray()
PHP: $oArrayNew = array_values(array_filter($oArray, fn($k)=>($k%$vNum == $vNum-1), ARRAY_FILTER_USE_KEY)) [also: $oArrayNew = array_values(array_filter($oArray, fn($v,$k)=>($k%$vNum == $vNum-1), ARRAY_FILTER_USE_BOTH))]
Python: oListNew = [v for k,v in enumerate(oList) if (k%vNum == vNum-1)]
R: oVecNew = oVec[seq(vNum, length(oVec), vNum)] [also: oVecNew = mapply(\(e) e[2], Filter(\(e) (as.integer(unlist(e)[1]) %% vNum == 0), oEntries))] [beforehand: oEntries = Map(c, 1:length(oVec), oVec)] [note: keys use 1-based indexes] [e.g. oVecNew = oVec[(1:length(oVec))%%3 == 0]] [e.g. oVecNew = oVec[seq_along(oVec)%%3 == 0]] [e.g. oVecNew = oVec[c(F, F, T)]]
Ruby: oArrayNew = oArray.select.with_index{|v,k| (k%vNum == vNum-1)} [also: oArrayNew = oArray.each_with_index.select{|v,k| (k%vNum == vNum-1)}.map{|vk|vk[0]}] [also: oArrayNew = oArray.filter_map.with_index{|v,k| v if (k%vNum == vNum-1)}]
Rust: oVecNew = oArray.iter().enumerate().filter(|(k,_)| (k%vNum == vNum-1)).map(|(_,v)| v).collect::<Vec<_>>()
Scala: oArrayNew = oArray.zipWithIndex.filter(_._2%vNum == vNum-1).map(_._1)
Swift: oArrayNew = oArray.enumerated().filter{($0.0%vNum == vNum-1)}.map{$1}
UFL: Array.GroupBy [split array to (a map of) subarrays based on a function][note: the map key names are the function output][see also: Array.Filter/Array.Partition]
AutoHotkey: ___
C++: for (const auto& vValue : oArray) oMap[oFunc(vValue)].push_back(vValue) [beforehand: std::map<int,std::vector<int>> oMap] [requires: #include <vector>] [requires: #include <map>] [WARNING: if vKey doesn't exist, 'oMap[vKey]' creates a key with the default value, e.g. an empty vector]
C#: oDict = oArray.GroupBy(oFunc).ToDictionary(g=>g.Key, g=>g.ToArray()) [requires: using System.Linq] [requires: using System.Collections.Generic]
Crystal: oMap = oArray.group_by(&oFunc) [also: oMap = oArray.group_by{|v| oFunc.call(v)}] [also: oMap = oArray.each_with_object({} of Int32=>Array(Int32)){|v,o| (o[oFunc.call(v)]||=[] of Int32)<<v}]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [e.g. int[] (note: remove 'boxed()' for String[]): var oMap = Arrays.stream(oArray).boxed().collect(Collectors.groupingBy(oFunc))] [also: var oMap = oList.collect(Collectors.groupingBy(oFunc))] [requires (Collectors): import java.util.stream.*]
JavaScript: ___ [e.g. (some browsers support): oMap = Map.groupBy(oArray, oFunc)] [e.g. (some browsers support): oObj = Object.groupBy(oArray, oFunc)] [note: Func receives item/index/array]
Kotlin: oMap = oArray.groupBy(oFunc) [also: oMap = oArray.groupBy{oFunc(it)}]
PHP: ___ [can use: foreach ($oArray as $v) $oMap[$oFunc($v)][] = $v] [WARNING: '$oMap[$vKey][] = $vValue' creates an array if it doesn't exist, and pushes] [beforehand: $oMap = []]
Python: for k,g in groupby(oListTemp, oFunc): oDict[k] = list(g) [beforehand: oListTemp = sorted(oList, key=oFunc); oDict = {}] [requires: from itertools import groupby]
R: oList = split(oVec, oFunc(oVec)) [e.g. oList = split(oVec, oVec %% 5)] [note: returns a list of lists]
Ruby: oMap = oArray.group_by(&oFunc) [also: oMap = oArray.group_by{|v| oFunc.call(v)}] [also: oMap = oArray.each_with_object({}){|v,o| (o[oFunc.call(v)]||=[])<<v}]
Rust: oMap: BTreeMap::<_,Vec<_>> = oArray.into_iter().fold(BTreeMap::new(), |mut a,v| {a.entry(oFunc(v)).or_default().push(v); a}) [requires: use std::collections::BTreeMap] [e.g. fn oFunc (vNum:i32) -> i32{vNum%3}] [note: also works with vectors]
Scala: oMap = oArray.groupBy(oFunc) [note: returns a map where each key is an array] [note: returns a map where each key is a list: oMapNew = oArray.groupBy(oFunc).view.mapValues(v=>v.toList).toMap] [note (both): also works with lists] [WARNING (all): groupBy doesn't preserve order] [e.g. preserve order: var oMap = scala.collection.mutable.LinkedHashMap[Int,List[Int]]().withDefaultValue(List[Int]()); oArray.foreach(v=>oMap(oFunc(v)):+=v)]
Swift: oDict = Dictionary(grouping:oArray, by:oFunc)
UFL: Array.GroupByWithIndex [split array to (a map of) subarrays (containing values but not indexes) based on a function (that receives values and indexes)][note: the map key names are the function output][note: workaround to do GroupBy using value *and key* (with index): array to entries (key-value pairs), to map of arrays of entries, to map of arrays of values][see also: Array.Filter/Array.Partition/(Array.Entries)/Array.FilterGetEveryNth/Array.Chunk/(Map.MultiFlip)]
AutoHotkey: ___
C++: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++) oMap[oFunc(i, oArray[i])].push_back(oArray[i]) [beforehand: std::map<int,std::vector<int>> oMap] [requires: #include <vector>] [requires: #include <map>] [WARNING: if vKey doesn't exist, 'oMap[vKey]' creates a key with the default value, e.g. an empty vector]
C#: oDict = oArray.Select((v,k)=>new{k=k,v=v}).GroupBy(e=>oFunc(e.k,e.v)).ToDictionary(g=>g.Key, g=>g.Select(e=>e.v).ToArray()) [requires: using System.Linq] [requires: using System.Collections.Generic]
Crystal: oMap = oArray.each_with_index.group_by{|v,k| oFunc.call(k,v)}.map{|k,v| [k,v.map{|v| v[0]}]}.to_h
Excel: ___
Excel VBA: ___
Go: ___
Java: var oMap = IntStream.range(0, oArray.length).boxed().collect(Collectors.groupingBy(i->oFunc.apply(i,oArray[i]), Collectors.mapping(i->oArray[i], Collectors.toList()))) [requires (Collectors): import java.util.stream.*]
JavaScript: ___ [e.g. (some browsers support): oMap = Map.groupBy(oArray, oFunc)] [e.g. (some browsers support): oObj = Object.groupBy(oArray, oFunc)] [note: Func receives item/index/array]
Kotlin: oMap = oArray.withIndex().groupBy({oFunc(it.index,it.value)}, {it.value})
PHP: ___ [can use: foreach ($oArray as $k=>$v) $oMap[$oFunc($k,$v)][] = $v] [WARNING: '$oMap[$vKey][] = $vValue' creates an array if it doesn't exist, and pushes] [beforehand: $oMap = []]
Python: ___ [can use: for k,g in groupby(oListTemp, oFunc): oDict[k] = list(map(lambda v : v[1], g))] [beforehand: oListTemp = sorted(enumerate(oList), key=oFunc); oDict = {}] [requires: from itertools import groupby] [note: where Func accepts one param, a key-value pair]
R: split(oVec, oFunc(seq_along(oVec), oVec)) [also: split(oVec, unlist(Map(oFunc, seq_along(oVec), oVec)))] [note: where oFunc accepts 2 params (k and v)]
Ruby: oArray.group_by.with_index{|v,k| oFunc.call(k,v)} [also: oMap = oArray.each_with_index.group_by{|v,k| oFunc.call(k,v)}.map{|k,v| [k,v.map{|v| v[0]}]}.to_h]
Rust: oMap: BTreeMap::<_,Vec<_>> = oArray.into_iter().enumerate().fold(BTreeMap::new(), |mut a,(k,v)| {a.entry(oFunc(k as i32,v)).or_default().push(v); a}) [requires: use std::collections::BTreeMap] [e.g. fn oFunc (vKey:i32, vValue:i32) -> i32{vKey%3}] [note: also works with vectors]
Scala: oMap = oArray.zipWithIndex.groupBy(oFunc).view.mapValues(v=>v.map(e=>e._1)).toMap [note: returns a map where each key is an array] [note: returns a map where each key is a list: oMap = oArray.zipWithIndex.groupBy(oFunc).view.mapValues(v=>v.map(e=>e._1).toList).toMap] [note (both): also works with lists] [WARNING (all): groupBy doesn't preserve order] [e.g. preserve order: var oMap = scala.collection.mutable.LinkedHashMap[Int,List[Int]]().withDefaultValue(List[Int]()); oArray.view.zipWithIndex.foreach((v,k)=>oMap(oFunc(k,v)):+=v)]
Swift: oDict = Dictionary(grouping:oArray.enumerated(), by:{oFunc($0,$1)}).mapValues{$0.map{$0.element}}
UFL: (Array.Partition) [create 2 separate arrays based on a filter (predicate)][see also: Array.Filter/Array.GroupBy][note: in some languages, 'partition' rearranges keys within an array]
AutoHotkey: ___
C++: auto oPivot = std::partition(std::begin(oArray), std::end(oArray), oFunc) [also: auto oPivot = std::partition(oVec.begin(), oVec.end(), oFunc)] [requires: #include <vector>] [requires (partition): #include <algorithm>] [note (array): false value count: vPivot = oPivot - oArray] [note (vector): false value count: vPivot = oPivot - oVec.begin()]
C#: oDict = oArray.GroupBy(oFunc).ToDictionary(g=>g.Key, g=>g.ToArray()) [requires: using System.Linq] [requires: using System.Collections.Generic]
Crystal: oTuple = oArray.partition(&oFunc) [also: oTuple = oArray.partition{|v| oFunc.call(v)}] [also: group_by()]
Excel: ___
Excel VBA: ___ [note: can use Filter() to list matches(/non-matches) that are a *substring* of a needle, case-sensitive/case-insensitive (integer values are treated as strings)]
Go: ___
Java: var oMap = Arrays.stream(oArray).boxed().collect(Collectors.partitioningBy(oFunc)) [also: var oMap = oList.stream().collect(Collectors.partitioningBy(oFunc))] [requires (Collectors): import java.util.stream.*]
JavaScript: ___ [e.g. (some browsers support): oMap = Map.groupBy(oArray, oFunc)] [e.g. (some browsers support): oObj = Object.groupBy(oArray, oFunc)]
Kotlin: (oArray1, oArray2) = oArray.partition(oFunc) [also: (oArray1, oArray2) = oArray.partition{oFunc(it)}] [also: oMap = oArray.groupBy(oFunc)]
PHP: ___ [can use: foreach ($oArray as $vValue) $oMap[$oFunc($vValue)][] = $vValue] [WARNING: '$oMap[$vKey][] = $vValue' creates an array if it doesn't exist, and pushes] [beforehand: $oMap = []]
Python: for k,g in groupby(oList, oFunc): oDict[k] = list(g) [beforehand: oList = sorted(oList, key=oFunc)] [beforehand: oDict = {}] [requires: from itertools import groupby]
R: oList = split(oVec, oFunc(oVec)) [e.g. oList = split(oVec, oVec %% 3 == 0)] [note: returns a list of lists]
Ruby: oArrayNew = oArray.partition(&oFunc) [also: oArrayNew = oArray.partition{|v| oFunc.call(v)}] [also: group_by()]
Rust: oMap: BTreeMap::<_,Vec<_>> = oArray.into_iter().fold(BTreeMap::new(), |mut a,v| {a.entry(oFunc(v)).or_default().push(v); a}) [requires: use std::collections::BTreeMap] [e.g. fn oFunc (vNum:i32) -> i32{vNum%2}] [note: also works with vectors]
Scala: var (oArrayT, oArrayF) = oArray.partition(oFunc) [also: var oTuple = oArray.partition(oFunc)] [note (both): also works with lists]
Swift: vPivot = oArray.partition(by:oFunc) [note: puts non-matches at start (before pivot) and matches at end (including pivot)] [WARNING: unstable sort (items are randomly shuffled)] [e.g. oNonMatch = oArray[..<vPivot].sorted()] [e.g. oMatch = oArray[vPivot...].sorted()]
UFL: Array.Chunk [or Array.GroupN][split array to subarrays of n keys (last subarray can contain fewer keys)][array to array of arrays][see also: Array.GroupByWithIndex/Array.SliceTo/StrChunk][see also (inverse): Array.Flat][note: copy keys rather than create references]
AutoHotkey: ___
C++: ___ [can use: for (int i=0; i<oVec.size(); i+=vCount) oVecNew.push_back(std::vector<int>(oVec.begin()+i, oVec.begin()+(i+vCount<oVec.size()?i+vCount:oVec.size())))] [beforehand: std::vector<std::vector<int>> oVecNew] [beforehand: oVecNew.reserve(oVec.size()/vCount+1)]
C#: oChunks = oArray.Chunk(vCount).ToArray()
Crystal: oChunks = oArray.each_slice(vCount).to_a
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use: int[][] oChunks = IntStream.iterate(0, i->i+vCount).limit((long)Math.ceil((double)oArray.length/vCount)).mapToObj(j->Arrays.copyOfRange(oArray, j, Math.min(j+vCount, oArray.length))).toArray(int[][]::new)] [requires: import java.util.*] [requires: import java.util.stream.*] [note: also works with strings, just replace 'int[][]' with 'String[][]' twice]
JavaScript: ___ [can use: oChunks = Array(Math.ceil(oArray.length/vCount)).fill().map((v,k)=>oArray.slice(k*vCount, k*vCount+vCount))]
Kotlin: oChunks = oArray.toList().chunked(vCount)
PHP: $oChunks = array_chunk($oArray, $vCount)
Python: oChunks = list(itertools.batched(oList, vCount)) [requires: import itertools] [also: oChunks = [oList[i:i+vCount] for i in range(0, len(oList), vCount)]]
R: oChunks = split(oVec, ceiling(seq_along(oVec)/vCount)) [note: returns a list of lists]
Ruby: oChunks = oArray.each_slice(vCount).to_a
Rust: oChunks: Vec<Vec<i32>> = oVec.chunks(vCount).map(|v| v.to_vec()).collect()
Scala: oArrayNew = oArray.grouped(vCount).toArray
Swift: ___ [can use: oChunks = stride(from:0, to:oArray.count, by:vCount).map{Array(oArray[$0..<min($0+vCount, oArray.count)])}]
UFL: Array.Zip [combine multiple arrays (of equal length) into an array of 'tuple' arrays, the first 'tuple' contains the first element of each input array][e.g. 'oArray1 = ["a1", "a2", "a3"]']
AutoHotkey: ___
C++: std::transform(oVec1.begin(), oVec1.end(), oVec2.begin(), std::back_inserter(oVecNew), [](const auto&v1, const auto&v2) {return std::vector<std::string>{v1,v2};}) [note: zips 2 vectors into a vector of vectors] [requires (transform): #include <algorithm>]
C#: var oArrayNew = oArray1.Zip(oArray2, (v1,v2)=>(v1,v2)).Zip(oArray3, (o,v)=>new String[]{o.v1,o.v2,v}).ToArray() [requires: using System.Linq]
Crystal: oArrayNew = oArray1.zip(oArray2, oArray3)
Excel: ___
Excel VBA: ___
Go: ___
Java: String[][] oArrayNew = IntStream.range(0, oArray1.length).mapToObj(i->new String[]{oArray1[i],oArray2[i],oArray3[i]}).collect(Collectors.toList()).toArray(String[][]::new) [also (for lists): List<List<String>> oArrayNew = IntStream.range(0, oArray1.length).mapToObj(i->Arrays.asList(oArray1[i],oArray2[i],oArray3[i])).collect(Collectors.toList())] [requires (IntStream/Collectors): import java.util.stream.*]
JavaScript: oArrayNew = oArray1.map((v,k)=>[v,oArray2[k],oArray3[k]])
Kotlin: oArrayNew = oArray1.mapIndexed{k,v->listOf(v,oArray2[k],oArray3[k])} [also (for 2 arrays only): oArrayNew = oArray1.zip(oArray2)]
PHP: $oArrayNew = array_map(null, $oArray1, $oArray2, $oArray3)
Python: oListNew = list(zip(oList1, oList2, oList3))
R: oListNew = list(oVec1, oVec2, oVec3)
Ruby: oArrayNew = oArray1.zip(oArray2, oArray3)
Rust: oVecNew = oArray1.into_iter().zip(oArray2.into_iter()).collect::<Vec<_>>() [note: also works with vectors]
Scala: oArrayNew = oArray1.zip(oArray2) [also: oArrayNew = oArray1.lazyZip(oArray2).lazyZip(oArray3).toArray] [note (both): returns an array of tuples] [note: also works with lists]
Swift: oArrayNew = zip(oArray1, zip(oArray2, oArray3)).map{[$0,$1.0,$1.1]} [note: for tuples, use '($0,$1.0,$1.1)' instead] [also (for 2 input arrays only, and for pairs): oArrayNew = zip(oArray1, oArray2).map{[$0,$1]}] [note: for tuples, remove '.map{[$0,$1]}']
UFL: (Array.SetMultOverwriteMap) [array overwrite/combine/merge, overwrite/add values, based on a map][see also: Map.LoopKeyValue]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___ [also (add/overwrite keys based on an array): $oArray1 = array_replace($oArray1, $oArray2, $oArray3)] [note: array_replace() overwrites keys] [WARNING: array_merge() appends index keys (and overwrites keys with string names)]
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: ___ [can use: for((k,v) <- oMap) oArray(k)=v]
Swift: ___
UFL: (Array.SetMultOverwriteEntries) [array overwrite/combine/merge, overwrite/add values, based on entries (key-value pairs)][e.g. oEntries = [[3,"d"]], contains 1 entry, it would set the value of key 3 to 'd', throwing if the array was too small][see also: Array.LoopValue]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: ___ [can use: for((k,v) <- oEntries) oArray(k)=v]
Swift: ___
UFL: (Array.SetMultSkipExistMap) [or Array.SetMultIfAbsent/Array.SetMultNoOverwrite][array combine, add values, if the key doesn't already exist, based on a map (add only, don't overwrite) (maintain original values)]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___ [also (add keys based on an array): $oArray1 += $oArray2] [note: assuming 2 arrays that satisfy array_is_list(), $oArray1 would only be modified if $oArray2 was longer ($oArray1 would receive the last keys of $oArray2)]
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: ___
Swift: ___
UFL: (Array.SetMultSkipExistEntries) [or Array.SetMultIfAbsent/Array.SetMultNoOverwrite][array combine, add values, if the key doesn't already exist, based on entries (key-value pairs) (add only, don't overwrite) (maintain original values)][e.g. oEntries = [[3,"d"]], would set the value of key 3 to 'd', if key 3 'didn't exist', throwing if the array was too small]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: ___
Swift: ___
UFL: Array.Default [define the default value returned when an element with no value is requested][see also: Array.GetOrDefault]
AutoHotkey: oArray.Default := vValue
C++: ___
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___ [note: array of type Variant/Integer/Double/String initialised with Empty/0/0/"" respectively]
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: ___
Swift: ___ [can use (to fill in blanks): oArray = oArray.map{$0 ?? vDefault}]
UFL: (Array.Next) [generate the next array e.g. [1,2,3] to [1,2,4], e.g. [1,9,9] to [2,0,0]][ideally: specify min/max values for each array item via an object][see also: StrNext]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: ___
Swift: ___
UFL: (Array.ToMap) [or Vector.ToMap][i.e. indexes become key names, values become values][see also: Array.PrintWithIndex/Array.Entries]
AutoHotkey: ___
C++: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++) oMap[i] = oArray[i] [beforehand: std::map<int,std::string> oMap]
C#: var oDict = oArray.Select((v,k)=>new{k,v}).ToDictionary(e=>e.k, e=>e.v)
Crystal: oMap = oArray.each_with_index.map{|v,k| [k,v]}.to_h [also: oMap = ((0...oArray.size).zip oArray).to_h] [also: oMap = Hash.zip((0...oArray.size).to_a, oArray)]
Excel: ___
Excel VBA: ___
Go: ___
Java: for (int i=0; i<oArray.length; i++) oMap.put(i, oArray[i]) [beforehand: LinkedHashMap<Integer,String> oMap = new LinkedHashMap<>()]
JavaScript: new Map(...[oArray.entries()])
Kotlin: oMap = oArray.mapIndexed{k,v->k to v!!}.toMap()
PHP: $oMap = $oArray [note: this creates a copy of the 'array' (the PHP array is a linear and associative array)] [note (to get integer keys only): $oArray = array_filter($oArray, fn($v,$k)=>is_int($k), ARRAY_FILTER_USE_BOTH)]
Python: oDict = {k:v for k,v in enumerate(oList)}
R: oMap = setNames(oVec, 1:length(oVec)) [also: oMap = setNames(oVec, seq_along(oVec))] [note: setNames param order: values then keys]
Ruby: oMap = oArray.map.with_index{|v,k| [k,v]}.to_h [also: oMap = ((0...oArray.length).zip oArray).to_h]
Rust: oMap = oArray.iter().enumerate().collect::<BTreeMap<_,_>>() [also: oMap = oVec.clone().into_iter().enumerate().collect::<BTreeMap<_,_>>()]
Scala: oMap = oArray.zipWithIndex.map(e=>(e._2,e._1)).toMap
Swift: oDict = Dictionary(uniqueKeysWithValues:oArray.enumerated().map{($0,$1)})
UFL: (Array.ToObject) [i.e. indexes become property names, values become values]
AutoHotkey: ___
C++: ___
C#: foreach (var oEntry in oArray.Select((v,k)=>new KeyValuePair<string,object>(k.ToString(),v))) ((IDictionary<string,object>)oObj).Add(oEntry)
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [see also: 'Object.ToMap'/'Object.Set']
JavaScript: oObj = {...oArray} [also: oObj = Object.assign({}, oArray)]
Kotlin: ___
PHP: $oObj = (object)$oArray
Python: oObj = SimpleNamespace(**{str(k):v for k,v in enumerate(oList)})
R: ___
Ruby: ___
Rust: ___
Scala: ___
Swift: ___
UFL: Array.ToSet [or Vector.ToSet][array to set][see also: Set.ToArray]
AutoHotkey: ___
C++: ___ [can use: int vSize = sizeof(oArray)/sizeof(oArray[0]); std::set<std::string>oSet(oArray, oArray+vSize)] [also (from vector): std::set<std::string>oSet(oVec.begin(), oVec.end())] [requires: #include <set>]
C#: oSet = new HashSet<string>(oArray) [requires: using System.Collections.Generic]
Crystal: oSet = oArray.to_set
Excel: ___
Excel VBA: ___
Go: ___
Java: oSet = new LinkedHashSet<String>(Arrays.asList(oArray)) [also (set of ints): oSet = new LinkedHashSet<Integer>(Arrays.asList(oArray))] [requires: import java.util.*]
JavaScript: oSet = new Set(oArray)
Kotlin: oSet = oArray.toMutableSet() [also: oSet = oArray.toSet()]
PHP: ___
Python: oSet = set(oList)
R: ___
Ruby: oSet = oArray.to_set [requires: require "set"]
Rust: oSet = HashSet::from(oArray) [requires: use std::collections::HashSet]
Scala: oSet = oArray.toSet
Swift: oSet = Set(oArray)
UFL: (Array.ToBuffer) [array of integers to binary data buffer]
AutoHotkey: ___
C++: for (int i=0; i<vSize; i++) oBuf[i] = (unsigned char)oArray[i] [beforehand: unsigned char* oBuf = new unsigned char[vSize]]
C#: byte[] oBuf = oArray.Select(v=>(byte)v).ToArray()
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: for (int i=0; i<oArray.length; i++) oBuf[i] = (byte)oArray[i] [beforehand: byte[] oBuf = new byte[oArray.length]]
JavaScript: oBuf = Uint8Array.from(oArray) [also: oBuf = new Uint8Array(oArray.length)]
Kotlin: oBuf = ByteArray(oArray.size){k->oArray[k]!!.toByte()} [note: the ByteArray constructor takes a size and an int-to-byte function: <init>(size: Int, init: (Int) -> Byte)] [also: oBuf = oArray.map{it.toByte()}.toByteArray()]
PHP: ___
Python: oBuf = bytearray(oList)
R: ___
Ruby: ___
Rust: oBuf: Vec<u8> = oVec.into_iter().map(|v| v as u8).collect()
Scala: oBuf = oArray.map(_.toByte)
Swift: oBuf = [UInt8](repeating:0, count:oArray.count).enumerated().map{oArray[$0.0]} [note: failed with $0]
UFL: Array.ToList [array to list]
AutoHotkey: ___
C++: ___ [e.g. int array: std::list<int> oList(std::begin(oArray), std::end(oArray))] [e.g. string array: std::list<std::string> oList(std::begin(oArray), std::end(oArray))] [requires: #include <list>]
C#: var oList = oArray.ToList() [requires (ToList): using System.Linq]
Crystal: ___
Excel: ___
Excel VBA: ___
Go: oSlice := oArray[:]
Java: ___ [e.g. int array: var oList = Arrays.stream(oArray).boxed().collect(Collectors.toList())] [e.g. string array: var oList = Arrays.asList(oArray)] [also: string array: var oList = Arrays.stream(oArray).collect(Collectors.toList())] [also: string array: var oList = new ArrayList<String>(Arrays.asList(oArray))] [WARNING: e.g. for String[]/Integer[] (but not int[]), if do 'oList = Arrays.asList(oArray)', modifying oList or oArray modifies both] [WARNING: e.g. for int[], if do 'oList = Arrays.asList(oArray)', oList contains 1 int[], not 0 or more ints] [requires (Collectors): import java.util.stream.*]
JavaScript: ___
Kotlin: var oList = oArray.toList() [also: var oList = oArray.toMutableList()]
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: oList = oArray.toList
Swift: ___
UFL: Array.FromList [or List.ToArray]
AutoHotkey: ___
C++: std::copy(oList.begin(), oList.end(), oArray) [beforehand (string array): auto* oArray = new std::string[oList.size()]] [beforehand (int array): auto* oArray = new int[oList.size()]] [requires (copy): #include <algorithm>]
C#: var oArray = oList.ToArray()
Crystal: ___
Excel: ___
Excel VBA: ___
Go: copy(oArray[:], oSlice) [note: if the array is smaller, values are omitted, if the array is larger, default values fill the gaps (e.g. 0/"")]
Java: ___ [e.g. int[] oArray = oList.stream().mapToInt(v->v).toArray()] [e.g. String[] oArray = oList.toArray(new String[0])] [note: 'String[0]' is an optimisation (alternatively: 'String[oArray.length]')]
JavaScript: ___
Kotlin: oArray = oList.toTypedArray()
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: oArray = oList.toArray
Swift: ___
UFL: Array.ToVector [array to vector]
AutoHotkey: ___
C++: ___ [e.g. int array: std::vector<int> oVec(std::begin(oArray), std::end(oArray))] [e.g. string array: std::vector<std::string> oVec(std::begin(oArray), std::end(oArray))] [requires: #include <vector>]
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: oVec = oArray.to_vec()
Scala: ___
Swift: ___
UFL: Array.FromVector [or Vector.ToArray]
AutoHotkey: ___
C++: std::copy(oVec.begin(), oVec.end(), oArray) [also: for (int i=0; i<oVec.size(); i++) oArray[i] = oVec[i]] [beforehand (string array): auto* oArray = new std::string[oVec.size()]] [beforehand (int array): auto* oArray = new int[oVec.size()]] [requires (copy): #include <algorithm>]
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: oArray = oVec.try_into().expect("my error message") [WARNING: array and vector must have the same length]
Scala: ___
Swift: ___
UFL: (Array.IntToStrArray) [int array to string array]
AutoHotkey: ___
C++: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++) oArrayNew[i] = std::to_string(oArray[i]) [e.g. int array to std::string array]
C#: oArrayNew = oArray.Select(v=>v.ToString()).ToArray()
Crystal: oArrayNew = oArray.map(&.to_s)
Excel: ___
Excel VBA: ___
Go: ___ [can use: oSliceNew := strings.Fields(strings.Trim(fmt.Sprint(oArray), "[]"))]
Java: for (int i=0; i<oArray.length; i++) oArrayNew[i] = "" + oArray[i] [beforehand: var oArrayNew = new String[oArray.length]] [also: String[] oArrayNew = Arrays.stream(oArray).mapToObj(String::valueOf).toArray(String[]::new)] [also: String[] oArrayNew = Arrays.stream(oArray).mapToObj(Integer::toString).toArray(String[]::new)] [also: var oListNew = oList.stream().map(Object::toString).collect(Collectors.toList())] [requires (Collectors): import java.util.stream.*]
JavaScript: oArrayNew = oArray.map(String) [also: oArrayNew = oArray.map(v=>String(v))]
Kotlin: oArrayNew = oArray.map{it.toString()}.toTypedArray() [also: oArrayNew = oArray.map{v->v.toString()}.toTypedArray()]
PHP: $oArrayNew = array_map("strval", $oArray) [also: $oArrayNew = array_map(fn($v)=>strval($v), $oArray)]
Python: oListNew = list(map(str, oList)) [also: oListNew = list(map(lambda v:str(v), oList))]
R: oVecNew = as.character(oVec)
Ruby: oArrayNew = oArray.map(&:to_s)
Rust: oVecNew = oArray.iter().map(|v| (*v).to_string()).collect::<Vec<_>>() [note: also works with vectors]
Scala: oArrayNew = oArray.map(_.toString) [note: also works with lists]
Swift: oArrayNew = oArray.map(String.init) [also: oArrayNew = oArray.map{String($0)}]
UFL: (Array.StrToIntArray) [string array to int array]
AutoHotkey: ___
C++: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++) oArrayNew[i] = std::stoi(oArray[i]) [e.g. std::string array to int array]
C#: oArrayNew = oArray.Select(v=>Int32.Parse(v)).ToArray()
Crystal: oArrayNew = oArray.map(&.to_i)
Excel: ___
Excel VBA: ___
Go: ___
Java: for (int i=0; i<oArray.length; i++) oArrayNew[i] = Integer.parseInt(oArray[i]) [beforehand: var oArrayNew = new String[oArray.length]] [also: int[] oArrayNew = Stream.of(oArray).mapToInt(Integer::parseInt).toArray()] [also: int[] oArrayNew = Arrays.stream(oArray).mapToInt(Integer::parseInt).toArray()] [also: var oListNew = oList.stream().mapToInt(Integer::parseInt).boxed().collect(Collectors.toList())] [requires (Collectors): import java.util.stream.*]
JavaScript: oArrayNew = oArray.map(v=>parseInt(v)) [WARNING: doesn't work because the key index is passed as the radix: oArray.map(parseInt)]
Kotlin: oArrayNew = oArray.map{it.toInt()}.toTypedArray() [also: oArrayNew = oArray.map{v->v.toInt()}.toTypedArray()]
PHP: $oArrayNew = array_map("intval", $oArray) [also: $oArrayNew = array_map(fn($v)=>intval($v), $oArray)]
Python: oListNew = list(map(int, oList)) [also: oListNew = list(map(lambda v:int(v), oList))]
R: oVecNew = as.integer(oVec) [also: oVecNew = as.numeric(as.integer(oVec))]
Ruby: oArrayNew = oArray.map(&:to_i)
Rust: oVecNew = oArray.iter().map(|v| v.parse::<i32>().unwrap()).collect::<Vec<_>>() [note: also works with vectors]
Scala: oArrayNew = oArray.map(_.toInt) [note: also works with lists]
Swift: oArrayNew = oArray.compactMap(Int.init) [also: oArrayNew = oArray.compactMap{Int($0)}]
UFL: (Array.IntToFloatArray) [int array to float array]
AutoHotkey: ___
C++: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++) oArrayNew[i] = (double)oArray[i]
C#: oArrayNew = oArray.Select(v=>(double)v).ToArray()
Crystal: oArrayNew = oArray.map(&.to_f)
Excel: ___
Excel VBA: ___
Go: ___
Java: for (int i=0; i<oArray.length; i++) oArrayNew[i] = (double)oArray[i] [beforehand: var oArrayNew = new double[oArray.length]] [also: double[] oArrayNew = IntStream.of(oArray).mapToDouble(v->(double)v).toArray()] [also: double[] oArrayNew = Arrays.stream(oArray).mapToDouble(v->(double)v).toArray()] [also: var oListNew = oList.stream().mapToDouble(v->v).boxed().collect(Collectors.toList())] [also: double[] oArrayNew = Arrays.stream(oArray).asDoubleStream().toArray()] [requires (Collectors): import java.util.stream.*]
JavaScript: oArrayNew = oArray [the Number type handles ints and floats]
Kotlin: oArrayNew = oArray.map{it.toDouble()}.toTypedArray() [also: oArrayNew = oArray.map{v->v.toDouble()}.toTypedArray()]
PHP: $oArrayNew = array_map("floatval", $oArray) [also: $oArrayNew = array_map(fn($v)=>floatval($v), $oArray)]
Python: oListNew = list(map(float, oList)) [also: oListNew = list(map(lambda v:float(v), oList))]
R: oVecNew = as.numeric(oVec)
Ruby: oArrayNew = oArray.map(&:to_f)
Rust: oVecNew = oArray.iter().map(|v| *v as f64).collect::<Vec<_>>() [note: also works with vectors]
Scala: oArrayNew = oArray.map(_.toDouble) [note: also works with lists]
Swift: oArrayNew = oArray.map{Double($0)}
UFL: (Array.FloatToIntArray) [float array to int array]
AutoHotkey: ___
C++: for (int i=0; i<sizeof(oArray)/sizeof(oArray[0]); i++) oArrayNew[i] = (int)oArray[i]
C#: oArrayNew = oArray.Select(v=>(int)v).ToArray()
Crystal: oArrayNew = oArray.map(&.to_i)
Excel: ___
Excel VBA: ___
Go: ___
Java: for (int i=0; i<oArray.length; i++) oArrayNew[i] = (int)oArray[i] [beforehand: var oArrayNew = new int[oArray.length]] [also: int[] oArrayNew = DoubleStream.of(oArray).mapToInt(v->(int)v).toArray()] [also: int[] oArrayNew = Arrays.stream(oArray).mapToInt(v->(int)v).toArray()] [also: var oListNew = oList.stream().mapToInt(v->v.intValue()).boxed().collect(Collectors.toList())] [requires (Collectors): import java.util.stream.*]
JavaScript: oArrayNew = oArray.map(v=>parseInt(v)) [WARNING: doesn't work because the key index is passed as the radix: oArray.map(parseInt)]
Kotlin: oArrayNew = oArray.map{it.toInt()}.toTypedArray() [also: oArrayNew = oArray.map{v->v.toInt()}.toTypedArray()]
PHP: $oArrayNew = array_map("intval", $oArray) [also: $oArrayNew = array_map(fn($v)=>intval($v), $oArray)]
Python: oListNew = list(map(int, oList)) [also: oListNew = list(map(lambda v:int(v), oList))]
R: oVecNew = as.integer(oVec) [also: oVecNew = as.numeric(as.integer(oVec))]
Ruby: oArrayNew = oArray.map(&:to_i)
Rust: oVecNew = oArray.iter().map(|v| *v as i32).collect::<Vec<_>>() [also: oVecNew = oArray.iter().map(|&v| v as i32).collect::<Vec<_>>()] [note: also works with vectors]
Scala: oArrayNew = oArray.map(_.toInt) [note: also works with lists]
Swift: oArrayNew = oArray.map{Int($0)}
Section: Map Methods
UFL: Map.Print [print the key-value pairs][see also: PrintKeyValue/Map.ToString]
AutoHotkey: ___
C++: for (const auto& [vKey, vValue] : oMap) std::cout << vKey << ":" << vValue << "\n"
C#: Console.WriteLine(String.Join("\n", oDict)) [also: Console.WriteLine(String.Join("\n", oDict.Select(e=>$"{e.Key}:{e.Value}")))] [requires (Select): using System.Linq]
Crystal: p oMap
Excel: ___
Excel VBA: ___
Go: fmt.Println(oMap) [requires: import "fmt"]
Java: System.out.println(oMap)
JavaScript: console.log(oMap) [also: console.log([...oMap.entries()].join("\n"))]
Kotlin: println(oMap)
PHP: var_export($oMap) [also: var_dump($oMap)] [also: print_r($oMap)]
Python: print(oDict)
R: for(vKey in names(oMap)) {print(paste(vKey, oMap[vKey], sep=": "))} [also: print(paste(names(oMap), oMap, sep = ": ", collapse = ", "))]
Ruby: p oMap
Rust: println!("{:?}", oMap) [also: println!("{:#?}", oMap)] [also (print using alphabetical/numerical order, via a BTreeMap): println!("{:?}", oMap.iter().collect::<BTreeMap<_,_>>())] [requires (BTreeMap): use std::collections::BTreeMap]
Scala: println(oMap)
Swift: print(oDict) [also (print using alphabetical/numerical order): print(oDict.map{($0,$1)}.sorted(by:{e1,e2 in e1.0<e2.0}))]
UFL: Map.LoopKeyValue [loop through the items of a map/dictionary, get key-value pairs one-by-one]
AutoHotkey: for k,v in oMap
C++: for (const auto& [k,v] : oMap)
C#: foreach (var oEntry in oDict) [also: foreach (KeyValuePair<string,string> oEntry in oDict)] [note: oEntry.Key, oEntry.Value] [requires: using System.Collections.Generic]
Crystal: oMap.each do |k,v| [afterwards: end]
Excel: ___
Excel VBA: For Each v In oColl [afterwards: Next] [WARNING: for a Collection object, can loop through values, but not keys, must store a list of keys manually]
Go: for k, v := range oMap
Java: for (var oEntry : oMap.entrySet()) [note: oEntry.getKey(), oEntry.getValue()]
JavaScript: for (const [k,v] of oMap) [also (ES6): oMap.forEach(function(v, k)]
Kotlin: for ((k,v) in oMap)
PHP: foreach ($oMap as $k=>$v)
Python: for k,v in oDict.items():
R: for(k in names(oMap)) [note: v = oMap[[k]]] [also: v = unname(oMap[k])] [note: double square brackets]
Ruby: for k,v in oMap [afterwards: end]
Rust: for (k,v) in &oMap [also: for oPair in &oMap] [note: can omit '&', if don't intend to iterate through map again]
Scala: for((k,v) <- oMap) [also (tuple): for(oEntry <- oMap)]
Swift: for (k,v) in oDict
UFL: Map.ForEach [or Map.LoopForEach][call a function once for each item of a map][see also: Map.LoopKeyValue]
AutoHotkey: ___
C++: ___ [can use: for (const auto& [k,v] : oMap) oFunc(k, v)]
C#: ___ [can use: foreach (var e in oDict) oFunc(e.Key,e.Value)] [note: e for entry]
Crystal: oMap.each{|k,v| oFunc.call(k,v)}
Excel: ___
Excel VBA: ___
Go: ___
Java: oMap.forEach(oFunc) [also: oMap.forEach((k,v)->oFunc.accept(k,v))] [note: Func receives key/value]
JavaScript: oMap.forEach(oFunc) [also: oMap.forEach((v,k)=>oFunc(k,v))] [note: Func receives value/key/object]
Kotlin: oMap.forEach(oFunc) [also: oMap.forEach{(k,v)->oFunc(k,v)}] [note: Func receives key/value]
PHP: ___ [can use: foreach ($oMap as $k=>$v) $oFunc($k,$v)]
Python: ___ [can use: for k,v in oDict.items(): oFunc(k,v)]
R: for(vKey in names(oMap)) {oFunc(vKey, oMap[vKey])}
Ruby: oMap.each_pair{|k,v| oFunc.call(k,v)}
Rust: oMap.iter().for_each(|(k,v)| oFunc(k,v))
Scala: oMap.foreach(oFunc) [also: oMap.foreach(e=>oFunc(e))] [also: oMap.foreach((k,v)=>oFunc(k,v))] [note: Func receives key/value]
Swift: oDict.forEach(oFunc) [also: oDict.forEach{oFunc($0,$1)}] [note: Func receives key/value]
UFL: Map.NewEmpty [or Map.NewBasic][create an empty map]
AutoHotkey: oMap := Map() [type: Map] [note: key order alphabetical (case-sensitive)] [note: AHK v1: key order alphabetical (case *insensitive*)]
C++: std::map<std::string,std::string> oMap [requires: #include <map>] [note: key order alphabetical (case-sensitive)] [type: (mangled) (e.g. <int,int>/<double,double>/<std::string,std::string> maps)]
C#: var oDict = new Dictionary<string,string> {} [requires: using System.Collections.Generic] [type: Dictionary`2 (e.g. <int,int>/<double,double>/<string,string> dictionaries)]
Crystal: oMap = {} of String => String [type: e.g. Hash(String, String)]
Excel: ___
Excel VBA: Set oColl = New Collection [also: Dim oColl As New Collection] [type: Collection] [note: 1-based] [note: an alternative class: Set oDict = CreateObject("Scripting.Dictionary")] [WARNING: Excel Collection keys can't be retrieved via a loop, so store them in a separate array/collection]
Go: oMap := make(map[string]string) [type: e.g. map[string]string]
Java: LinkedHashMap<String,String> oMap = new LinkedHashMap<>() [requires: import java.util.*] [type: LinkedHashMap]
JavaScript: oMap = new Map() [type: Map]
Kotlin: oMap = mutableMapOf<String, String>() [also: mapOf()] [type (mutableMapOf): LinkedHashMap] [type (mapOf): SingletonMap]
PHP: $oMap = [] [type: array] [also: array()] [note: an associative array that also has linear array functions]
Python: oDict = {} [type: dict]
R: oMap = character(0) [e.g. type: character] [e.g. oMap = numeric(0)] [e.g. type: double (class: numeric)] [also (1-item map to 0-item map): oMap = c(0)[-1]] [note: 1-based] [WARNING: for vectors, typeof/class report the type of the item] [i.e. for a 'map', we use a vector with named values]
Ruby: oMap = {} [type: Hash]
Rust: let mut oMap: HashMap<&str,&str> = HashMap::new() [type: e.g. std::collections::hash::map::HashMap<&str, &str>] [requires: use std::collections::HashMap]
Scala: oMap = scala.collection.mutable.LinkedHashMap[String,String]() [type: LinkedHashMap] [also: var oMap = scala.collection.mutable.Map[String,String]()] [type (Map): HashMap]
Swift: oDict = [String: String]() [type: e.g. Dictionary<String,String>] [WARNING: 'random' key order, not insertion order] [can use (insertion order, but allows duplicates) e.g. oDict: KeyValuePairs = ["k1":"v1", "k2":"v2", "k3":"v3"]]
UFL: (Map.NewStrDemo) [initialise a map/dictionary with 3 items]
AutoHotkey: oMap := Map("k1","v1", "k2","v2", "k3","v3")
C++: std::map<std::string,std::string> oMap = {{"k1","v1"},{"k2","v2"},{"k3","v3"}}
C#: var oDict = new Dictionary<string,string> {{"k1","v1"},{"k2","v2"},{"k3","v3"}} [requires: using System.Collections.Generic]
Crystal: oMap = {"k1"=>"v1","k2"=>"v2","k3"=>"v3"}
Excel: ___
Excel VBA: ___ [e.g. Set oColl = New Collection] [e.g. Call oColl.Add("v1", "k1")]
Go: oMap := map[string]string{"k1": "v1", "k2": "v2", "k3": "v3"}
Java: LinkedHashMap<String,String> oMap = Arrays.stream(oEntries).collect(LinkedHashMap::new, (a,e)->a.put(e[0],e[1]), Map::putAll) [also: for (String[] e : oEntries) oMap.put(e[0], e[1])] [also (random order, not insertion order): HashMap<String,String> oMap = new HashMap<>(Map.of("k1","v1", "k2","v2", "k3","v3"))] [e.g. String[][] oEntries = {{"k1","v1"},{"k2","v2"},{"k3","v3"}}] [requires: import java.util.*] [e.g. empty string/string map: LinkedHashMap<String,String> oMap = new LinkedHashMap<>()]
JavaScript: oMap = new Map([["k1","v1"], ["k2","v2"], ["k3","v3"]])
Kotlin: oMap = mutableMapOf("k1" to "v1", "k2" to "v2", "k3" to "v3") [also: mapOf()]
PHP: $oMap = ["k1"=>"v1", "k2"=>"v2", "k3"=>"v3"]
Python: oDict = {"k1":"v1", "k2":"v2", "k3":"v3"}
R: oMap = c("k1"="v1", "k2"="v2", "k3"="v3") [note: workaround: using names as 'keys'] [WARNING: names can be used multiple times, they don't have to be unique]
Ruby: oMap = {"k1"=>"v1","k2"=>"v2","k3"=>"v3"}
Rust: let mut oMap = HashMap::from([("k1","v1"), ("k2","v2"), ("k3","v3")]) [requires: use std::collections::HashMap]
Scala: oMap = scala.collection.mutable.LinkedHashMap("k1"->"v1", "k2"->"v2", "k3"->"v3") [also: var oMap = Map("k1"->"v1", "k2"->"v2", "k3"->"v3")]
Swift: oDict = ["k1":"v1", "k2":"v2", "k3":"v3"]
UFL: (Map.NewStrIntDemo) [initialise a map/dictionary with 3 items][see also: Tuple.NewDemo]
AutoHotkey: oMap := Map("k1",1, "k2",2, "k3",3)
C++: std::map<std::string,int> oMap = {std::make_pair("k1",1),std::make_pair("k2",2),std::make_pair("k3",3)} [requires (make_pair): #include <utility>]
C#: var oDict = new[]{("k1",1),("k2",2),("k3",3)}.ToDictionary() [requires: using System.Linq] [requires: using System.Collections.Generic]
Crystal: oMap = {"k1"=>1,"k2"=>2,"k3"=>3}
Excel: ___
Excel VBA: ___ [e.g. Set oColl = New Collection] [e.g. Call oColl.Add(1, "k1")]
Go: oMap := map[string]int{"k1": 1, "k2": 2, "k3": 3}
Java: LinkedHashMap<String,Integer> oMap = Arrays.stream(oEntries).collect(LinkedHashMap::new, (a,e)->a.put(e[0],Integer.parseInt(e[1])), Map::putAll) [also: for (String[] e : oEntries) oMap.put(e[0], Integer.parseInt(e[1]))] [also (random order, not insertion order): HashMap<String,Integer> oMap = new HashMap<>(Map.of("k1",1, "k2",2, "k3",3))] [e.g. (store ints as strings, to later convert them to ints) String[][] oEntries = {{"k1","1"},{"k2","2"},{"k3","3"}}] [requires: import java.util.*] [e.g. empty string/int map: LinkedHashMap<String,Integer> oMap = new LinkedHashMap<>()]
JavaScript: oMap = new Map([["k1",1], ["k2",2], ["k3",3]])
Kotlin: oMap = mutableMapOf("k1" to 1, "k2" to 2, "k3" to 3) [also: mapOf()]
PHP: $oMap = ["k1"=>1, "k2"=>2, "k3"=>3]
Python: oDict = {"k1":1, "k2":2, "k3":3}
R: oMap = c("k1"=1, "k2"=2, "k3"=3)
Ruby: oMap = {"k1"=>1,"k2"=>2,"k3"=>3}
Rust: let mut oMap = HashMap::from([("k1",1), ("k2",2), ("k3",3)]) [requires: use std::collections::HashMap]
Scala: oMap = scala.collection.mutable.LinkedHashMap("k1"->1, "k2"->2, "k3"->3) [also: var oMap = Map("k1"->1, "k2"->2, "k3"->3)]
Swift: oDict = ["k1":1, "k2":2, "k3":3]
UFL: (Map.OrderType) [insertion order, alphabetical order, 'random' order (unordered)][e.g. what order does a loop return]
AutoHotkey: ___ [item order: Map: alphabetical (case-sensitive)/numerical] [note: AHK v1: item order: alphabetical (case-*insensitive*)/numerical] [can use (insertion order map): Scripting.Dictionary]
C++: ___ [item order: map: alphabetical (case-sensitive)/numerical] [also: item order: unordered_map: 'random']
C#: ___ [item order: Dictionary: insertion]
Crystal: ___ [item order: Hash: insertion]
Excel: ___
Excel VBA: ___
Go: ___ [item order: map: insertion]
Java: ___ [item order: LinkedHashMap: insertion (or optionally access)] [WARNING: item order: HashMap: 'random']
JavaScript: ___ [item order: Map: insertion]
Kotlin: ___ [item order: LinkedHashMap (mutableMapOf): insertion]
PHP: ___ [item order: array: insertion]
Python: ___ [item order: dict: insertion]
R: ___ [item order: character/double (vector): insertion]
Ruby: ___ [item order: Hash: insertion]
Rust: ___ [item order: BTreeMap: alphabetical (case-sensitive)/numerical] [item order: HashMap: 'random']
Scala: ___ [item order: LinkedHashMap: insertion]
Swift: ___ [WARNING: item order: Dictionary: 'random']
UFL: Map.Keys [get keys as an array]
AutoHotkey: oKeys := [oMap*]
C++: for (const auto& [vKey, _] : oMap) oKeys.push_back(vKey) [beforehand: std::vector<std::string> oKeys] [beforehand (also): oKeys.reserve(oMap.size())]
C#: var oKeys = oDict.Keys.ToArray()
Crystal: oKeys = oMap.keys
Excel: ___
Excel VBA: ___
Go: ___
Java: String[] oKeys = oMap.keySet().toArray(new String[oMap.size()])
JavaScript: oKeys = [...oMap.keys()] [also (returns an iterator): oKeys = oMap.keys()]
Kotlin: oKeys = oMap.keys
PHP: $oKeys = array_keys($oMap)
Python: oKeys = list(oDict) [also: oDict.keys()]
R: oKeys = names(oMap)
Ruby: oKeys = oMap.keys
Rust: oKeys = oMap.keys()
Scala: oKeys = oMap.keys().toArray
Swift: oKeys = oDict.keys
UFL: Map.Values [get values as an array]
AutoHotkey: oValues := [oMap.__Enum(2).Bind(&_)*]
C++: for (const auto& [_, vValue] : oMap) oValues.push_back(vValue) [beforehand: std::vector<std::string> oValues] [beforehand (also): oValues.reserve(oMap.size())]
C#: var oValues = oDict.Values.ToArray()
Crystal: oValues = oMap.values
Excel: ___
Excel VBA: ___
Go: ___
Java: String[] oValues = oMap.values().toArray(new String[oMap.size()])
JavaScript: oValues = [...oMap.values()] [also (returns an iterator): oValues = oMap.values()]
Kotlin: oValues = oMap.values
PHP: $oValues = array_values($oMap)
Python: oValues = oDict.values()
R: oValues = unname(oMap)
Ruby: oValues = oMap.values
Rust: oValues = oMap.values()
Scala: oValues = oMap.values().toArray
Swift: oValues = oDict.values
UFL: Map.Entries [or Map.ToEntries][map to entries (key-value pairs)]
AutoHotkey: ___
C++: for (const auto& [vKey, vValue] : oMap) oEntries.push_back({vKey, vValue}) [beforehand: std::vector<std::vector<std::string>> oEntries] [beforehand (also): oEntries.reserve(oMap.size())] [note: returns a vector of vectors] [also (to handle values of different types): std::pair]
C#: string[][] oEntries = oDict.Select(e=>new[]{e.Key,e.Value}).ToArray() [note: returns an array of arrays]
Crystal: oEntries = oMap.to_a [note: returns an array of tuples]
Excel: ___
Excel VBA: ___
Go: ___
Java: String[][] oEntries = oMap.entrySet().stream().map(e->new String[]{e.getKey(),e.getValue()}).toArray(String[][]::new) [note: returns an array of tuples]
JavaScript: oEntries = [...oMap.entries()] [note: returns an array of arrays] [also (returns an iterator): oEntries = oMap.entries()]
Kotlin: oEntries = oMap.entries.toTypedArray() [note: returns an array of entries] [also (returns an iterator): oEntries = oMap.entries] [also (returns an array of pairs): oEntries = oMap.toList().toTypedArray()]
PHP: foreach ($oMap as $vKey=>$vValue) array_push($oEntries, [$vKey, $vValue]) [beforehand: $oEntries = []] [also: $oEntries = array_map(function($oKey) use ($oMap) {return [$oKey, $oMap[$oKey]];}, array_keys($oMap))] [note: returns an array of arrays]
Python: oEntries = list(oDict.items()) [note: returns a list of tuples] [also (returns an iterator): oEntries = oDict.items()]
R: oEntries = Map(c, names(oMap), oMap, USE.NAMES=FALSE) [note: returns a list]
Ruby: oEntries = oMap.to_a [note: returns an array of arrays]
Rust: oEntries: Vec<(&&str,&&str)> = oMap.iter().collect() [note: returns a vector of tuples]
Scala: oEntries = oMap.toArray [note: returns an array of tuples]
Swift: oEntries = oDict.keys.map{[$0,oDict[$0]!]} [note: returns an array of arrays] [also (to tuples): oEntries = oDict.map{($0,$1)}]
UFL: Map.Count [get key count][see also: Array.CountNonNull]
AutoHotkey: vCount := oMap.Count
C++: vCount = oMap.size()
C#: vCount = oDict.Count
Crystal: vCount = oMap.size
Excel: ___
Excel VBA: vCount = oColl.Count
Go: vCount = len(oMap)
Java: vCount = oMap.size()
JavaScript: vCount = oMap.size
Kotlin: vCount = oMap.size [also: oMap.count()]
PHP: $vCount = count($oMap) [also: sizeof($oMap)]
Python: vCount = len(oDict)
R: vCount = length(oMap) [also (exclude NAs): vCount = length(na.omit(oVec))]
Ruby: vCount = oMap.size
Rust: vCount = oMap.len()
Scala: vCount = oMap.size
Swift: vCount = oDict.count
UFL: Map.Has [or Map.HasKey][does map have key with key name]
AutoHotkey: vHasKey := oMap.Has(vKey)
C++: vHasKey = oMap.count(vKey) [note: the 1-param version (overload) acts as a has-key method, returning 1 or 0]
C#: vHasKey = oDict.ContainsKey(vKey)
Crystal: vHasKey = oMap.has_key?(vKey) [also: oMap.includes?({vKey, vValue})] [WARNING: includes?() checks for a key-value pair, not a key]
Excel: ___
Excel VBA: ___ [can use: 'Call oColl.Item(vKey)' with 'On Error GoTo', i.e. if it throws, the key doesn't exist]
Go: vValue, vHasKey := oMap[vKey]
Java: vHasKey = oMap.containsKey(vKey)
JavaScript: vHasKey = oMap.has(vKey)
Kotlin: vHasKey = oMap.contains(vKey)
PHP: $vHasKey = array_key_exists($vKey, $oMap)
Python: vHasKey = vKey in oDict [inverse: vKey not in oDict]
R: vHasKey = vKey %in% names(oMap)
Ruby: vHasKey = oMap.include?(vKey) [also (aliases): has_key?/member?/key?]
Rust: vHasKey = oMap.contains_key(vKey)
Scala: vHasKey = oMap.contains(vKey)
Swift: vHasKey = oDict.keys.contains(vKey) [also: vHasKey = (oDict[vKey] != nil)]
UFL: (Map.GetDemo) [map get key value]
AutoHotkey: vValue := oMap["MyKey"]
C++: vValue = oMap.at("MyKey") [also: vValue = oMap["MyKey"]]
C#: vValue = oDict["MyKey"]
Crystal: vValue = oMap["MyKey"]
Excel: ___
Excel VBA: vValue = oColl.Item("MyKey")
Go: vValue := oMap["MyKey"] [also: vValue, vHasKey := oMap["MyKey"]] [WARNING: non-existent key: returns default value (e.g. 0/"")]
Java: vValue = oMap.get("MyKey")
JavaScript: vValue = oMap.get(vKey) [WARNING: gets property: vValue = oMap["MyKey"]]
Kotlin: vValue = oMap["MyKey"]
PHP: $vValue = $oMap["MyKey"]
Python: vValue = oDict["MyKey"]
R: vValue = oMap["MyKey"]
Ruby: vValue = oMap["MyKey"]
Rust: vValue = oMap.get("MyKey").cloned().unwrap() [also: vValue = oMap["MyKey"]]
Scala: vValue = oMap.get("MyKey").get
Swift: vValue = oDict["MyKey"]
UFL: Map.Get [or Map[Key]][map get key value]
AutoHotkey: vValue := oMap[vKey] [also: vValue := oMap.Get(vKey)] [note: non-existent key: oMap[] and oMap.Get() throw]
C++: vValue = oMap.at(vKey) [also: vValue = oMap[vKey]] [note: 'at' throws if key doesn't exist] [WARNING: oMap[vKey]: if vKey doesn't exist, 'vValue = oMap[vKey]' creates a key with the default value, e.g. 0/""]
C#: vValue = oDict[vKey] [note: non-existent key: throws]
Crystal: vValue = oMap[vKey]
Excel: ___
Excel VBA: vValue = oColl.Item(vKey) [also: oColl.Item(vIndex) / oColl(vKey) / oColl(vIndex)] [note: non-existent key: throws] [WARNING: it is not possible to get a list of a collection's key names]
Go: vValue := oMap[vKey] [also: vValue, vHasKey := oMap[vKey]] [WARNING: non-existent key: returns default value (e.g. 0/"")]
Java: vValue = oMap.get(vKey) [note: non-existent key: returns null]
JavaScript: vValue = oMap.get(vKey) [note: non-existent key: returns undefined] [WARNING: gets property: vValue = oMap[vProp]]
Kotlin: oOpt = oMap[vKey] [also: oOpt = oMap.get(vKey)] [note: non-existent key: returns null] [note: oMap[vKey] returns a nullable, oArray[vKey] returns a non-nullable (unless it's an array of nullables)] [e.g. vIsNull = (oOpt == null)] [e.g. vValue = oOpt!!]
PHP: $vValue = $oMap[$vKey] [note: non-existent key: returns NULL]
Python: vValue = oDict[vKey] [note: non-existent key: throws]
R: vValue = oMap[vKey]
Ruby: vValue = oMap[vKey]
Rust: vValue = oMap.get(vKey).cloned().unwrap() [also: vValue = oMap[vKey]]
Scala: vValue = oMap.get(vKey).get [note: non-existent key: get() returns None]
Swift: vValue = oDict[vKey]! [note: non-existent key: throws]
UFL: Map.GetOrDefault [if key non-existent/null, provide default (deviations from this are noted)]
AutoHotkey: vValue := oMap.Get(vKey, vDefault)
C++: ___
C#: vValue = oDict.GetValueOrDefault(vKey, vDefault) [WARNING: returns null if value is null] [note: if default omitted, the defaults for int/double/string are 0/0/"" respectively] [also: oDict[vKey] ?? vDefault] [WARNING: oDict[vKey] throws if key doesn't exist]
Crystal: vValue = oMap.fetch(vKey, vDefault)
Excel: ___
Excel VBA: ___
Go: ___
Java: vValue = oMap.getOrDefault(vKey, vDefault) [WARNING: returns null if value is null] [also (appears to give the same results, except it returns default rather than null): Optional.ofNullable(oMap.get(vKey)).orElse(vDefault)]
JavaScript: vValue = oMap.get(vKey) ?? vDefault [note: returns default if value is null/undefined]
Kotlin: vValue = oMap.getOrElse(vKey, oFunc) [e.g. oMap.getOrElse(vKey){vDefault}] [e.g. oMap.getOrElse(vKey, {vDefault})] [note (unlike arrays): returns default if value is null] [also (appears to give the same results): oMap[vKey] ?: vDefault] [note: oMap[vKey] returns null if key doesn't exist]
PHP: $vValue = $oMap[$vKey] ?? $vDefault
Python: vValue = oDict.get(vKey, vDefault) [WARNING: returns None if value is None]
R: ___ [can use: vValue = na.omit(c(oMap[vKey], vDefault))[1]] [note: 1-based]
Ruby: vValue = oMap.fetch(vKey, vDefault)
Rust: vValue = oMap.get(vKey).cloned().unwrap_or(vDefault)
Scala: vValue = oMap.getOrElse(vKey, vDefault)
Swift: vValue = oDict[vKey, default:vDefault] [WARNING: returns optional nil if value is optional nil] [also: vValue = oDict[vKey] ?? vDefault] [note: both approaches appear to give the same results] [note (both): returns default if key doesn't exist] [note: oDict[vKey] returns nil if key doesn't exist]
UFL: (Map.SetDemo) [map set key value]
AutoHotkey: oMap["MyKey"] := "MyValue"
C++: oMap["MyKey"] = "MyValue"
C#: oDict["MyKey"] = "MyValue"
Crystal: oMap["MyKey"] = "MyValue"
Excel: ___
Excel VBA: Call oColl.Add("MyValue", "MyKey")
Go: oMap["MyKey"] = "MyValue"
Java: oMap.put("MyKey", "MyValue")
JavaScript: oMap.set("MyKey", "MyValue") [WARNING: sets property: oMap["MyKey"] = "MyValue"]
Kotlin: oMap["MyKey"] = "MyValue"
PHP: $oMap["MyKey"] = "MyValue"
Python: oDict["MyKey"] = "MyValue"
R: oMap["MyKey"] = "MyValue"
Ruby: oMap["MyKey"] = "MyValue"
Rust: oMap.insert("MyKey", "MyValue")
Scala: oMap("MyKey") = "MyValue" [also: oMap.put("MyKey", "MyValue")]
Swift: oDict["MyKey"] = "MyValue"
UFL: Map.Set [or Map[Key]][map set key value]
AutoHotkey: oMap[vKey] := vValue [also: oMap.Set(vKey, vValue)]
C++: oMap[vKey] = vValue [WARNING: oMap.insert({vKey,vValue}) *doesn't* overwrite keys]
C#: oDict[vKey] = vValue
Crystal: oMap[vKey] = vValue
Excel: ___
Excel VBA: Call oColl.Add(vValue, vKey) [WARNING: value then key] [WARNING: key names are *case-insensitive* strings] [note: key names are optional, however, every key has a 1-based index] [note: to 'modify' a value you use Remove then Add (the key order can be maintained via Add's Before/After params)]
Go: oMap[vKey] = vValue
Java: oMap.put(vKey, vValue)
JavaScript: oMap.set(vKey, vValue) [WARNING: sets property: oMap[vProp] = vValue]
Kotlin: oMap[vKey] = vValue [also: oMap.set(vKey, vValue)] [also: oMap.put(vKey, vValue)]
PHP: $oMap[$vKey] = $vValue
Python: oDict[vKey] = vValue [also: oMap.update({vKey:vValue})] [WARNING: oMap.setdefault(vKey, vValue) *doesn't* overwrite keys]
R: oMap[vKey] = vValue
Ruby: oMap[vKey] = vValue
Rust: oMap.insert(vKey, vValue) [note: insert() can both add and modify keys] [WARNING: oMap[vKey] syntax can be used to read keys, but not add/modify them]
Scala: oMap(vKey) = vValue [also: oMap.put(vKey, vValue)]
Swift: oDict[vKey] = vValue
UFL: Map.ForcePush [a map of arrays: append an item to an array, create the array if it doesn't exist][workaround: specify 'new array' as the default value][perhaps a better name exists, we're pushing to a key, not to the object itself][see also: Map.Default]
AutoHotkey: ___
C++: oMap[vKey].push_back(vValue) [beforehand: std::map<std::string,std::vector<std::string>> oMap] [requires: #include <vector>] [requires: #include <map>] [WARNING: if vKey doesn't exist, 'oMap[vKey]' creates a key with the default value, e.g. an empty vector]
C#: ___
Crystal: (oMap[vKey] ||= [] of String) << vValue [beforehand: oMap = {} of String=>Array(String)] [WARNING: a||=b equivalent to a?a:a=b not a=a||b]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: $oMap[$vKey][] = $vValue [beforehand: $oMap = []] [WARNING: '$oMap[$vKey][] = $vValue' creates an array if it doesn't exist, and pushes]
Python: ___
R: ___
Ruby: (oMap[vKey] ||= []) << vValue [beforehand: oMap = {}] [WARNING: a||=b equivalent to a?a:a=b not a=a||b]
Rust: ___
Scala: ___
Swift: ___
UFL: (Map.Fill) [or Map.SetAll][set all keys to the same value]
AutoHotkey: ___
C++: ___ [can use: for (auto& [_,v] : oMap) v = vValue] [also: std::for_each(oMap.begin(), oMap.end(), [&](auto &p){p.second = vValue;})] [also: std::ranges::fill and std::ranges::views::values]
C#: ___ [can use: foreach (var k in oDict.Keys.ToList()) oDict[k] = vValue] [also: oDict.Keys.ToList().ForEach(k=>oDict[k]=vValue)]
Crystal: oMap.transform_values!{|v| vValue} [note: omit '!' to return a new map]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use: for (var oEntry : oMap.entrySet()) {oMap.put(oEntry.getKey(), vValue);}]
JavaScript: ___ [can use: [...oMap.keys()].forEach(k=>oMap.set(k, vValue))]
Kotlin: oMap.replaceAll{_,_ -> vValue}
PHP: ___ [can use: foreach ($oMap as $k=>$v) $oMap[$k] = $vValue]
Python: ___ [can use: for k,v in oDict.items(): oDict[k] = vValue]
R: oMap[] = vValue [note: leaves names ('keys') unchanged]
Ruby: oMap.transform_values!{|v| vValue} [note: omit '!' to return a new map]
Rust: for v in oMap.values_mut() {*v = vValue;}
Scala: ___ [can use: for((k,v) <- oMap) oMap(k) = vValue]
Swift: ___ [can use: for (k,_) in oDict {oDict[k] = vValue}]
UFL: Map.Swap [swap 2 elements]
AutoHotkey: ___
C++: std::swap(oMap[vKey1], oMap[vKey2]) [also: std::swap(oMap.at(vKey1), oMap.at(vKey2))] [WARNING: if vKey doesn't exist, 'oMap[vKey]' creates a key with the default value, e.g. 0/""]
C#: (oDict[vKey1], oDict[vKey2]) = (oDict[vKey2], oDict[vKey1]) [note: destructuring assignment]
Crystal: oMap[vKey1], oMap[vKey2] = oMap[vKey2], oMap[vKey1] [note: destructuring assignment]
Excel: ___
Excel VBA: ___
Go: oMap[vKey1], oMap[vKey2] = oMap[vKey2], oMap[vKey1] [note: destructuring assignment]
Java: ___
JavaScript: ___
Kotlin: ___
PHP: [$oMap[$vKey1], $oMap[$vKey2]] = [$oMap[$vKey2], $oMap[$vKey1]] [note: destructuring assignment]
Python: oDict[vKey1], oDict[vKey2] = oDict[vKey2], oDict[vKey1] [note: destructuring assignment]
R: ___
Ruby: oMap[vKey1], oMap[vKey2] = oMap[vKey2], oMap[vKey1] [note: destructuring assignment]
Rust: ___
Scala: oMapNew = oMap.clone.addOne(vKey1, oMap(vKey2)).addOne(vKey2, oMap(vKey1)) [deprecated: oMapNew = oMap.updated(vKey1, oMap(vKey2)).updated(vKey2, oMap(vKey1))]
Swift: (oDict[vKey1], oDict[vKey2]) = (oDict[vKey2], oDict[vKey1]) [note: destructuring assignment] [note: swap() fails with 'overlapping accesses' error: swap(&oDict[vKey1], &oDict[vKey2])]
UFL: Map.Delete [delete a key]
AutoHotkey: oMap.Delete(vKey)
C++: oMap.erase(vKey)
C#: oDict.Remove(vKey)
Crystal: oMap.delete(vKey)
Excel: ___
Excel VBA: oColl.Remove(vKey) [also: oColl.Remove(vIndex)]
Go: delete(oMap, vKey)
Java: oMap.remove(vKey)
JavaScript: oMap.delete(vKey)
Kotlin: oMap.remove(vKey)
PHP: $oMap[$vKey] = null [also: unset($oMap[$vKey])]
Python: del oDict[vKey] [also: oDict.pop(vKey) and oDict.popitem(vKey)]
R: oMapNew = oMap[names(oMap) != vKey]
Ruby: oMap.delete(vKey)
Rust: oMap.remove(vKey)
Scala: oMap.remove(vKey)
Swift: oDict[vKey] = nil
UFL: Map.Clear [delete all keys]
AutoHotkey: oMap.Clear()
C++: oMap.clear()
C#: oDict.Clear()
Crystal: oMap.clear
Excel: ___
Excel VBA: Set oColl = New Collection
Go: clear(oMap)
Java: oMap.clear()
JavaScript: oMap.clear()
Kotlin: oMap.clear()
PHP: $oMap = [] [also: array_splice($oMap, 0, count($oMap))] [note: appears to work even if the map has no '0' key]
Python: oDict.clear()
R: oMap = head(oMap, 0)
Ruby: oMap.clear
Rust: oMap.clear()
Scala: oMap.clear
Swift: oDict.removeAll()
UFL: Map.Clone [or Map.Copy][copy the entire map]
AutoHotkey: oMapNew := oMap.Clone()
C++: std::map<std::string,std::string> oMapNew = oMap [WARNING: this creates a copy, not a reference]
C#: var oDictNew = new Dictionary<string,string>(oDict)
Crystal: oMapNew = oMap.clone
Excel: ___
Excel VBA: ___ [note: 'Set oCollNew = oColl' creates a reference, unlike arrays, where 'Set oArrayNew = oArray' is invalid, and 'oArrayNew = oArray' clones the array]
Go: ___ [WARNING: Go maps lack a clone method]
Java: var oMapNew = new LinkedHashMap<>(oMap)
JavaScript: oMapNew = new Map(oMap)
Kotlin: oMapNew = oMap.toMutableMap() [also: oMapNew = oMap.toMap()]
PHP: $oMapNew = $oMap [WARNING: this creates a copy, not a reference]
Python: oDictNew = oDict.copy()
R: oMapNew = oMap [WARNING: this creates a copy, not a reference]
Ruby: oMapNew = oMap.clone
Rust: oMapNew = oMap.clone()
Scala: oMapNew = oMap.clone
Swift: oDictNew = oDict [WARNING: this creates a copy, not a reference]
UFL: Map.FromEntries [or Entries.ToMap][create a map from an array of entries, each entry is an array containing a key and a value][e.g. 'oEntries = [["k1","v1"], ["k2","v2"], ["k3","v3"]]']
AutoHotkey: ___
C++: ___ [e.g. oMap.insert({{"k1","v1"}, {"k2","v2"}, {"k3","v3"}})] [e.g. oMap.insert(oEntries.begin(), oEntries.end())] [beforehand: std::map<std::string,std::string> oMap] [beforehand (also): std::pair<std::string,std::string> oEntries[] = {{"k1","v1"}, {"k2","v2"}, {"k3","v3"}}]
C#: var oDict = oEntries.ToDictionary(e=>e[0], e=>e[1])
Crystal: oMap = oEntries.to_h [e.g. oEntries = [["k1","v1"], ["k2","v2"], ["k3","v3"]]]
Excel: ___
Excel VBA: ___
Go: ___
Java: LinkedHashMap<String,String> oMap = Arrays.stream(oEntries).collect(LinkedHashMap::new, (a,e)->a.put(e[0],e[1]), Map::putAll) [also: for (String[] e : oEntries) oMap.put(e[0], e[1])] [e.g. LinkedHashMap<String,String> oMap = new LinkedHashMap<>()] [e.g. String[][] oEntries = {{"k1","v1"},{"k2","v2"},{"k3","v3"}}] [also: Map<String,String> oMap = IntStream.range(0, oEntries.length).boxed().collect(Collectors.toMap(i->oEntries[i][0], i->oEntries[i][1]))] [requires (Collectors): import java.util.stream.*]
JavaScript: oMap = new Map(oEntries)
Kotlin: oMap = oEntries.map{Pair(it[0],it[1])}.toMap() [also: oMap = oEntries.map{e->Pair(e[0],e[1])}.toMap()] [e.g. oEntries = arrayOf(arrayOf("k1","v1"), arrayOf("k2","v2"), arrayOf("k3","v3"))] [also: oMap = oEntriesPairs.toMap()] [e.g. oEntriesPairs = arrayOf(Pair("k1", "v1"), Pair("k2", "v2"), Pair("k3", "v3"))]
PHP: array_reduce($oEntries, function($vAccum, $oEntry) use (&$oMap) {$oMap[$oEntry[0]] = $oEntry[1];}) [beforehand: $oMap = []]
Python: oDict = dict(oEntries)
R: oMap = setNames(sapply(oEntries, "[[", 2), sapply(oEntries, "[[", 1)) [e.g. oEntries = Map(c, c("k1","k2","k3"), c("v1","v2","v3"), USE.NAMES=FALSE)]
Ruby: oMap = oEntries.to_h [e.g. oEntries = [["k1","v1"], ["k2","v2"], ["k3","v3"]]]
Rust: oMap = HashMap::from(oEntries) [e.g. oEntries = [("k1","v1"), ("k2","v2"), ("k3","v3")]] [also: oMap = oEntriesVec.clone().into_iter().collect::<HashMap<_,_>>()] [e.g. oEntriesVec: Vec<_> = vec![("k1","v1"), ("k2","v2"), ("k3","v3")]]
Scala: oMap = oEntries.toMap [e.g. specify map type: scala.collection.mutable.LinkedHashMap.from(oEntries)]
Swift: oDict = Dictionary(uniqueKeysWithValues:oEntries.map{($0[0],$0[1])}) [note: failed with $0 and $1]
UFL: Map.FromFlatEntries [create a map from an array of alternating keys/values][e.g. 'oFlatEntries = ["k1","v1", "k2","v2", "k3","v3"]'][see also: Array.Chunk/Map.FromEntries/Array.Zip/Array.GroupBy/Array.FilterGetEveryNth]
AutoHotkey: oMap := Map(oFlatEntries*)
C++: ___
C#: oDict = oFlatEntries.Chunk(2).ToDictionary(e=>e[0], e=>e[1])
Crystal: oMap = oFlatEntries.each_slice(2).to_h
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: oMap = new Map(Array(oFlatEntries.length/2).fill().map((v,k)=>oFlatEntries.slice(k*2, k*2+2)))
Kotlin: oMap = oFlatEntries.toList().chunked(2).map{Pair(it[0],it[1])}.toMap()
PHP: array_reduce(array_chunk($oFlatEntries, 2), function($vAccum, $oEntry) use (&$oMap) {$oMap[$oEntry[0]] = $oEntry[1];}) [beforehand: $oMap = []]
Python: oDict = dict(itertools.batched(oFlatEntries, 2)) [requires: import itertools] [also: oDict = dict([oFlatEntries[i:i+2] for i in range(0, len(oFlatEntries), 2)])]
R: oMap = setNames(oVec[c(F, T)], oVec[c(T, F)]) [note: can use TRUE/FALSE instead of T/F]
Ruby: oMap = oFlatEntries.each_slice(2).to_h
Rust: oMap = oFlatEntries.chunks(2).map(|e| (e[0],e[1])).collect::<HashMap<_,_>>()
Scala: oMap = oArray.grouped(2).map(v=>(v(0),v(1))).toMap [e.g. specify map type: scala.collection.mutable.LinkedHashMap.from(oEntries)]
Swift: oDict = Dictionary(uniqueKeysWithValues:zip(oTemp[0]!, oTemp[1]!)) [beforehand: var oTemp = Dictionary(grouping:oFlatEntries.enumerated(), by:{$0.0%2}).mapValues{$0.map{$0.element}}] [also (approach 2): oDict = Dictionary(uniqueKeysWithValues:oEntries.map{($0[0],$0[1])}) [beforehand (approach 2): oEntries = stride(from:0, to:oFlatEntries.count, by:2).map{Array(oFlatEntries[$0..<min($0+2, oFlatEntries.count)])}]
UFL: Map.FromTwoArrays [or Map.FromKeysValues][create a map by combining a key array and a value array (of equal length)][see also: Array.Zip]
AutoHotkey: ___
C++: ___ [can use: std::map::insert() multiple times]
C#: var oDict = oKeys.Zip(oValues, (k,v)=>new{k,v}).ToDictionary(e=>e.k, e=>e.v) [also: var oDict = Enumerable.Range(0, oKeys.Length).ToDictionary(i=>oKeys[i], i=>oValues[i])] [requires: using System.Linq]
Crystal: oMap = oKeys.zip(oValues).to_h
Excel: ___
Excel VBA: ___
Go: ___
Java: Map<String,String> oMap = IntStream.range(0, oKeys.length).boxed().collect(Collectors.toMap(i->oKeys[i], i->oValues[i])) [requires (Collectors): import java.util.stream.*]
JavaScript: oMap = new Map(oKeys.map((v,k)=>[v,oValues[k]])) [note: where v is a key name, and k is an array index]
Kotlin: oMap = oKeys.zip(oValues).toMap()
PHP: $oMap = array_combine($oKeys, $oValues)
Python: oDict = dict(zip(oKeys, oValues))
R: oMap = setNames(oValues, oKeys)
Ruby: oMap = oKeys.zip(oValues).to_h
Rust: oMap = oKeys.into_iter().zip(oValues.into_iter()).collect::<HashMap<_,_>>() [also (loop): for (k,v) in oKeys.into_iter().zip(oValues.into_iter()) {oMap.insert(k,v);}] [beforehand (loop): let mut oMap: HashMap<&str,&str> = HashMap::new()] [e.g. oKeys = ["k1", "k2", "k3"]] [e.g. oValues = ["v1", "v2", "v3"]]
Scala: oMap = oArray1.zip(oArray2).toMap [e.g. specify map type: scala.collection.mutable.LinkedHashMap.from(oEntries)]
Swift: oDict = Dictionary(uniqueKeysWithValues:zip(oKeys, oValues))
UFL: Map.SetMultOverwriteMap [map overwrite/combine/merge, overwrite/add values, based on another map][see also: Map.ForEach/Map.FromEntries]
AutoHotkey: ___ [can use (replace ';' with LF): for vKey, vValue in oMapAddIn; oMap[vKey] := vValue]
C++: ___ [can use: for (const auto& [vKey, vValue] : oMapAddIn) oMap[vKey] = vValue]
C#: ___ [can use: foreach (var e in oDictAddIn) oDict[e.Key] = e.Value]
Crystal: oMap.merge!(oMapAddIn) [note: in Crystal, update() modifies 1 key based on a function, it doesn't merge 2 maps]
Excel: ___
Excel VBA: ___
Go: maps.Copy(oMap, oMapAddIn)
Java: oMap.putAll(oMapAddIn)
JavaScript: oMap = new Map([...oMap, ...oMapAddIn, ...oMapAddIn2])
Kotlin: oMap += oMapAddIn [WARNING: unlike PHP, this overwrites keys]
PHP: $oMap = array_replace($oMap, $oMapAddIn, $oMapAddIn2) [also: $oMap = array_merge($oMap, $oMapAddIn, $oMapAddIn2)] [note: array_replace treats all key names consistently, array_merge uses special handling for numeric keys]
Python: oDict.update(oDictAddIn) [also: oDict |= oDictAddIn] [also: oDict = {**oDict, **oDictAddIn, **oDictAddIn2}]
R: ___ [can use: oMap[names(oMapAddIn)] = oMapAddIn] [e.g. oMap = c("k1"="v1", "k2"="v2", "k3"="v3")]
Ruby: oMap.update(oMapAddIn) [note: alias: merge]
Rust: oMap.extend(oMapAddIn.clone())
Scala: oMap.addAll(oMapAddIn)
Swift: oDict = oDict.merging(oDictAddIn){(_,v2) in v2} [note: '{(_,v2) in v2}': it receives 2 values and returns 1]
UFL: Map.SetMultOverwriteEntries [map overwrite/combine/merge, overwrite/add values, based on entries (key-value pairs)][see also: Map.FromEntries]
AutoHotkey: ___ [can use: oMap.Set(vKey1,vValue1, vKey2,vValue2, vKey3,vValue3)] [can use (replace ';' with LF): for _, oEntry in oEntries; oMap[oEntry[1]] := oEntry[2]]
C++: ___ [can use: for (const auto& [vKey, vValue] : oEntries) oMap[vKey] = vValue]
C#: ___ [can use: foreach (var e in oEntries) oDict[e[0]] = e[1]]
Crystal: oMap.merge!(oEntries.to_h) [note: in Crystal, update() modifies 1 key based on a function, it doesn't merge 2 maps]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use: for (var e : oEntries) oMap.put(e[0], e[1])]
JavaScript: oMap = new Map([...oMap, ...oEntries])
Kotlin: ___ [can use: for (oEntry in oEntries) oMap[oEntry[0]] = oEntry[1]]
PHP: ___ [can use: foreach ($oEntries as $e) $oMap[$e[0]] = $e[1]]
Python: oDict.update(oEntries)
R: ___
Ruby: oMap.update(oEntries.to_h) [note: alias: merge]
Rust: ___ [can use: for [vKey, vValue] in &oEntries {oMap.insert(vKey, vValue);}]
Scala: oMap.addAll(oEntries)
Swift: ___ [can use: for e in oEntries {oDict[e[0]] = e[1]}]
UFL: Map.SetMultSkipExistMap [or Map.SetMultIfAbsent/Map.SetMultNoOverwrite][map combine, add values, if the key doesn't already exist, based on another map (add only, don't overwrite) (maintain original values)][see also: Map.ForEach/Map.FromEntries]
AutoHotkey: ___ [can use (replace ';' with LF): for vKey, vValue in oMapAddIn; if !oMap.Has(vKey); oMap[vKey] := vValue]
C++: ___ [can use: for (const auto& [vKey, vValue] : oMapAddIn) oMap.insert({vKey,vValue})] [WARNING: insert() *doesn't* overwrite keys]
C#: ___ [can use: foreach (var e in oDictAddIn) if (!oDict.ContainsKey(e.Key)) oDict[e.Key] = e.Value]
Crystal: oMap.merge!(oMapAddIn){|k,v1,v2| v1} [note: in Crystal, update() modifies 1 key based on a function, it doesn't merge 2 maps]
Excel: ___
Excel VBA: ___
Go: ___
Java: oMapAddIn.forEach(oMap::putIfAbsent)
JavaScript: ___ [can use: oMapAddIn.forEach((v,k)=>!oMap.has(k) && oMap.set(k,v))]
Kotlin: oMap += oMapAddIn - oMap.keys
PHP: $oMap += $oMapAddIn [note: unlike Kotlin, this *doesn't* overwrite keys]
Python: ___ [can use: oDictCopy = oDict.copy(); oDict.update(oDictAddIn); oDict.update(oDictCopy)] [can use (replace ';' with LF): for vKey, vValue in oDictAddIn.items():; if vKey not in oDict:; oDict[vKey] = vValue]
R: ___
Ruby: oMap.update(oMapAddIn){|k,v1,v2| v1} [note: alias: merge]
Rust: ___ [can use: for (vKey, vValue) in &oMapAddIn {if !oMap.contains_key(vKey) {oMap.insert(vKey, vValue);}}]
Scala: oMapAddIn.foreach((k,v)=>oMap.getOrElseUpdate(k,v))
Swift: oDict = oDict.merging(oDictAddIn){(v1,_) in v1} [note: '{(v1,_) in v1}': it receives 2 values and returns 1]
UFL: Map.SetMultSkipExistEntries [or Map.SetMultIfAbsent/Map.SetMultNoOverwrite][map combine, add values, if the key doesn't already exist, based on entries (key-value pairs) (add only, don't overwrite) (maintain original values)][see also: Map.FromEntries]
AutoHotkey: ___ [can use (replace ';' with LF): for _, oEntry in oEntries; if !oMap.Has(oEntry[1]); oMap[oEntry[1]] := oEntry[2]]
C++: ___ [e.g. oMap.insert({{"k1","v1"}, {"k2","v2"}, {"k3","v3"}})] [e.g. oMap.insert(oEntries.begin(), oEntries.end())] [WARNING: insert() *doesn't* overwrite keys]
C#: ___ [can use: foreach (var e in oEntries) if (!oDict.ContainsKey(e[0])) oDict[e[0]] = e[1]]
Crystal: oMap.merge!(oEntries.to_h){|k,v1,v2| v1} [note: in Crystal, update() modifies 1 key based on a function, it doesn't merge 2 maps]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use: for (var e : oEntries) if (!oMap.containsKey(e[0])) oMap.put(e[0], e[1])]
JavaScript: ___ [can use: oEntries.forEach(e=>!oMap.has(e[0]) && oMap.set(...e))]
Kotlin: ___ [can use: for (oEntry in oEntries) if (!oMap.contains(oEntry[0])) oMap[oEntry[0]] = oEntry[1]]
PHP: ___ [can use: foreach ($oEntries as $e) !array_key_exists($e[0], $oMap) && $oMap[$e[0]] = $e[1]]
Python: ___ [can use: oDictCopy = oDict.copy(); oDict.update(oEntries); oDict.update(oDictCopy)] [can use (replace ';' with LF): for oEntry in oEntries:; if oEntry[0] not in oDict:; oDict[oEntry[0]] = oEntry[1]]
R: ___
Ruby: oMap.update(oEntries.to_h){|k,v1,v2| v1} [note: alias: merge]
Rust: ___ [can use: for [vKey, vValue] in &oEntries {if !oMap.contains_key(vKey) {oMap.insert(vKey, vValue);}}]
Scala: oEntries.foreach((k,v)=>oMap.getOrElseUpdate(k,v))
Swift: ___ [can use: for e in oEntries {if (!oDict.keys.contains(e[0])) {oDict[e[0]] = e[1]}}]
UFL: Map.Flip [flip keys/values][assumes no duplicates amongst values][see also: Array.Zip/Map.MapValues]
AutoHotkey: ___ [can use (replace ';' with LF): oMapNew := Map(); for vKey, vValue in oMap; oMapNew[vValue] := vKey]
C++: for (auto e = oMap.begin(); e != oMap.end(); ++e) oMapNew[e->second] = e->first [beforehand: std::map<std::string,std::string> oMapNew]
C#: oDictNew = oDict.ToDictionary(e=>e.Value, e=>e.Key) [requires: using System.Linq] [requires: using System.Collections.Generic]
Crystal: oMapNew = oMap.invert
Excel: ___
Excel VBA: ___
Go: ___
Java: for (var e : oMap.entrySet()) oMapNew.put(e.getValue(), e.getKey()) [beforehand: LinkedHashMap<String,String> oMapNew = new LinkedHashMap<>()] [also: var oMapNew = oMap.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey))] [requires (Collectors): import java.util.stream.*]
JavaScript: oMapNew = new Map(Array.from(oMap, e=>e.reverse())) [also: oMapNew = new Map(Array.from(oMap, ([k,v])=>[v,k]))]
Kotlin: oMapNew = oMap.map{(k,v)->v to k}.toMap()
PHP: $oMapNew = array_flip($oMap)
Python: oDictNew = {v:k for k,v in oDict.items()} [also: oDictNew = dict((v,k) for k,v in oDict.items())] [also: oDictNew = dict(zip(oDict.values(), oDict.keys()))]
R: oMapNew = setNames(names(oMap), unname(oMap)) [note: setNames param order: values then keys]
Ruby: oMapNew = oMap.invert
Rust: oMapNew: HashMap::<_,_> = oMap.iter().map(|(k,v)| (v,k)).collect()
Scala: oMapNew = oMap.map(_.swap) [note: preserves map type]
Swift: oDictNew = Dictionary(uniqueKeysWithValues:oDict.map{($1,$0)})
UFL: Map.MultiFlip [or Map.FlipMulti][flip keys/values][handles duplicates amongst values][key-value pairs to key-array pairs]
AutoHotkey: ___ [can use (replace ';' with LF): oMapNew := Map(); for vKey, vValue in oMap; if oMapNew.Has(vValue); oMapNew[vValue].Push(vKey); else; oMapNew[vValue] := [vKey]]
C++: for (const auto& [vKey, vValue] : oMap) oMapNew[vValue].push_back(vKey) [beforehand: std::map<std::string,std::vector<std::string>> oMapNew] [requires: #include <vector>] [requires: #include <map>] [WARNING: if vKey doesn't exist, 'oMap[vKey]' creates a key with the default value, e.g. an empty vector]
C#: oDictNew = oDict.GroupBy(e=>e.Value).ToDictionary(g=>g.Key, g=>g.Select(e=>e.Key).ToArray()) [requires: using System.Linq] [requires: using System.Collections.Generic]
Crystal: oMapNew = oMap.each_with_object({} of String=>Array(String)){|(k,v),o| (o[v]||=[] of String)<<k} [WARNING: a||=b equivalent to a?a:a=b not a=a||b] [also: oMapNew = oMap.each_with_object({} of String=>Array(String)){|(k,v),o| o.has_key?(v) ? o[v]<<k : (o[v]=[k])}]
Excel: ___
Excel VBA: ___
Go: ___
Java: var oMapNew = oMap.entrySet().stream().collect(Collectors.groupingBy(Map.Entry::getValue, Collectors.mapping(Map.Entry::getKey, Collectors.toList()))) [requires (Collectors): import java.util.stream.*]
JavaScript: for (const [k,v] of oMap) oMapNew.has(v) ? oMapNew.get(v).push(k) : oMapNew.set(v, [k]) [beforehand: oMapNew = new Map()]
Kotlin: oMapNew = oMap.entries.groupBy({it.value}, {it.key}) [also: oMapNew = oMap.toList().groupBy{it.second}.mapValues{it.value.map{it.first}}]
PHP: foreach ($oMap as $vKey=>$vValue) $oMapNew[$vValue][] = $vKey [WARNING: '$oMap[$vKey][] = $vValue' creates an array if it doesn't exist, and pushes] [beforehand: $oMapNew = []]
Python: for k,v in oDict.items(): oDictNew.setdefault(v, []).append(k) [beforehand: oDictNew = {}] [also: for k,v in oDict.items(): oDictNew[v] = oDictNew.get(v, []) + [k]]
R: oList = split(oMap, unname(oMap)) [afterwards: for(vKey in names(oList)) oList[[vKey]] = names(oList[[vKey]])]
Ruby: oMapNew = oMap.each_with_object({}){|(k,v),o| (o[v]||=[])<<k} [WARNING: a||=b equivalent to a?a:a=b not a=a||b] [also: oMapNew = oMap.each_with_object({}){|(k,v),o| o.include?(v) ? o[v]<<k : o[v]=[k]}]
Rust: oMapNew: HashMap::<_,Vec<_>> = oMap.iter().fold(HashMap::new(), |mut a,e| {a.entry(e.1).or_default().push(e.0); a}) [also (loop): for (k,v) in &oMap {oMapNew.entry(v).or_default().push(k);}] [beforehand (loop): let mut oMapNew = BTreeMap::<_, Vec<_>>::new()] [requires: use std::collections::BTreeMap]
Scala: oMapNew = oMap.toList.groupBy(_._2).view.mapValues(_.map(_._1)).toMap [e.g. specify map type: scala.collection.mutable.LinkedHashMap.from(oEntries)] [WARNING (all): groupBy doesn't preserve order] [e.g. preserve order: var oMapNew = scala.collection.mutable.LinkedHashMap[String,List[String]]().withDefaultValue(List[String]()); oMap.foreach((k,v)=>oMap(v):+=k)]
Swift: oDictNew = Dictionary(oDict.map{($1,[$0])}, uniquingKeysWith:{(v1,v2) in v1+v2})
UFL: Map.MapValues [map values: apply a function to each value][see also: Map.Flip/Map.Values/Array.Zip/Map.FromEntries]
AutoHotkey: ___
C++: ___
C#: oDictNew = oDict.ToDictionary(e=>e.Key, e=>oFunc(e.Value)) [requires: using System.Linq] [requires: using System.Collections.Generic]
Crystal: oMapNew = oMap.transform_values{|v| oFunc.call(v)} [also: oMapNew = oMap.transform_values(&oFunc)]
Excel: ___
Excel VBA: ___
Go: ___
Java: var oMapNew = oMap.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e->oFunc.apply(e.getValue()))) [requires (Collectors): import java.util.stream.*]
JavaScript: oMapNew = new Map(Array.from(oMap, e=>[e[0],oFunc(e[1])]))
Kotlin: oMapNew = oMap.mapValues{oFunc(it)} [also: oMapNew = oMap.mapValues(oFunc)]
PHP: ___ [can use: foreach ($oMap as $vKey=>$vValue) $oMapNew[$vKey] = $oFunc($vValue)] [beforehand: $oMapNew = []]
Python: oDictNew = {k:oFunc(v) for k,v in oDict.items()} [also: oDictNew = dict((k,oFunc(v)) for k,v in oDict.items())] [also: oDictNew = dict(zip(oDict.keys(), map(oFunc, oDict.values())))]
R: oMapNew = mapply(oFunc, oMap)
Ruby: oMapNew = oMap.transform_values{|v| oFunc.call(v)} [also: oMapNew = oMap.transform_values(&oFunc)]
Rust: oMapNew: HashMap::<_,_> = oMap.iter().map(|(k,v)| (k,oFunc(v.to_string()).to_string())).collect()
Scala: oMapNew = oMap.view.mapValues(oFunc).toMap [also: var oMapNew = oMap.view.mapValues(oFunc(_)).toMap] [e.g. specify map type: scala.collection.mutable.LinkedHashMap.from(oEntries)]
Swift: oDictNew = oDict.mapValues{oFunc($0)} [also: oDictNew = oDict.mapValues(oFunc)]
UFL: Map.KeyOf [return first key that contains value][can be used as Map.HasVal/Map.Any][see also: Array.IndexOf/Array.HasVal/Array.Any/Array.Find]
AutoHotkey: ___
C++: ___ [can use: auto oIter = std::find_if(std::begin(oMap), std::end(oMap), [&](const std::pair<std::string, std::string> &pair) {return pair.second == vNeedle;})] [afterwards (1): auto vIsMatch = (oIter != std::end(oMap))] [afterwards (2): auto vKey = oIter->first] [requires (find_if): #include <algorithm>]
C#: vKey = oDict.FirstOrDefault(e=>e.Value == vNeedle).Key
Crystal: vKey = oMap.key_for(vNeedle) [note: throws if no match]
Excel: ___
Excel VBA: ___
Go: ___
Java: oOpt = oMap.entrySet().stream().filter(e->e.getValue()==vNeedle).findFirst().map(Map.Entry::getKey) [note: findFirst() returns an optional, map() modifies a non-empty optional, and leaves unchanged an empty optional] [also (other languages): safe navigation operator, Rust's map_or()]
JavaScript: ___ [can use: vKey = [...oMap.entries()].find(e=>e[1]==vNeedle)[0]]
Kotlin: vKey = oMap.entries.find{it.value == vNeedle}?.key [note: returns null if no match]
PHP: $vKey = array_search($vNeedle, $oMap) [WARNING: returns false if no match]
Python: vKey = next((k for k,v in oDict.items() if v == vNeedle), None)
R: vKey = names(oMap)[match(vValue, oMap)] [note: returns NA if no match]
Ruby: vKey = oMap.key(vNeedle) [note: returns nil if no match]
Rust: oOpt = oMap.iter().find_map(|(k,&v)| if v == vNeedle {Some(k)} else {None}) [e.g. vIsMatch = oOpt.is_some()] [e.g. vValue = oOpt.unwrap_or(vDefault)] [e.g. vValue = oOpt.unwrap()]
Scala: oOptKey = oMap.find(_._2==vNeedle).map(_._1) [also: vKey = oMap.find(_._2==vNeedle).get._1] [note: find() returns an optional, map() modifies a non-empty optional, and leaves unchanged an empty optional]
Swift: vKey = oDict.first(where:{$0.value == vNeedle})?.key [note: returns nil if no match]
UFL: (Map.Equals) [do the contents of 2 maps match (at least one level deep) (same key-value pairs)]
AutoHotkey: ___
C++: vIsMatch = (oMap1 == oMap2)
C#: ___ [can use: vIsMatch = (oDict1.Count == oDict2.Count) && oDict1.Keys.All(k=>oDict2.ContainsKey(k) && (oDict1[k] == oDict2[k]))]
Crystal: vIsMatch = (oMap1 == oMap2)
Excel: ___
Excel VBA: ___
Go: vIsMatch := reflect.DeepEqual(oMap1, oMap2) [requires: import "reflect"]
Java: vIsMatch = oMap1.equals(oMap2)
JavaScript: ___ [can use: vIsMatch = (oMap1.size == oMap2.size) && Array.from(oMap1.keys()).every(k=>oMap2.has(k) && (oMap1.get(k) === oMap2.get(k)))]
Kotlin: vIsMatch = oMap1.equals(oMap2) [also: vIsMatch = (oMap1 == oMap2)]
PHP: $vIsMatch = ($oMap1 === $oMap2) [note: == compares contents, === compares contents (stricter), neither compare references]
Python: vIsMatch = (oDict1 == oDict2)
R: vIsMatch = identical(oMap1, oMap2)
Ruby: vIsMatch = (oMap1 == oMap2)
Rust: vIsMatch = oMap1.eq(&oMap2)
Scala: vIsMatch = oMap1.equals(oMap2) [also: vIsMatch = (oMap1 == oMap2)]
Swift: vIsMatch = (oDict1 == oDict2)
UFL: Map.Default [define the default value returned when an element with no value is requested][see also: Map.GetOrDefault/Map.ForcePush]
AutoHotkey: oMap.Default := vDefault
C++: ___ [note: if vKey doesn't exist, 'oMap[vKey]' creates a key with the default value, e.g. 0/""/an empty vector] [note: if vKey doesn't exist, 'oMap[vKey]++' creates a key with the default value, e.g. 0, then increments it]
C#: ___
Crystal: ___ [can use (when creating a map): oMap = Hash(String,Int32).new(vDefault)] [can use (modify existing map): if do oMap1.merge!(oMap2), oMap2 will determine the default value]
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___ [note: '$oMap[$vKey][] = $vValue' creates an array if it doesn't exist, and pushes] [also (increment using default 0): $oMap[$vKey] = ($oMap[$vKey] ?? 0) + 1]
Python: ___ [can use (when creating a dict): oDict = defaultdict(oFunc)] [e.g. oDict = defaultdict(lambda: 0)] [e.g. oDict = defaultdict(list)] [requires: from collections import defaultdict]
R: ___
Ruby: oMap.default = vDefault [also (when creating a map): oMap = Hash.new(vDefault)]
Rust: ___
Scala: ___ [e.g. new map: var oMap = scala.collection.mutable.LinkedHashMap[String,Int]().withDefaultValue(0)] [e.g. new map: var oMap = Map[String,Int]().withDefaultValue(0)] [e.g. modifiable default value: var oMap = Map[String,Int]().withDefault(k=>vDefault)]
Swift: ___
UFL: (Map.ToObject) [map to object]
AutoHotkey: ___
C++: ___
C#: foreach (var oEntry in oDict) ((IDictionary<string,object>)oObj).Add(oEntry) [beforehand: dynamic oObj = new ExpandoObject()] [requires (ExpandoObject): using System.Dynamic]
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [can use: for (var oEntry : oMap.entrySet())] [note: oEntry.getKey(), oEntry.getValue()] [see also: 'Object.ToMap'/'Object.Set']
JavaScript: oObj = Object.fromEntries(oMap.entries())
Kotlin: ___
PHP: $oObj = (object)$oMap
Python: oObj = SimpleNamespace(**oDict)
R: ___
Ruby: ___
Rust: ___
Scala: ___
Swift: ___
UFL: Map.ToString [map to string][see also: String/Map.Print]
AutoHotkey: ___
C++: ___
C#: ___ [can use: String.Join("\n", oDict)] [can use: String.Join("\n", oDict.Select(e=>$"{e.Key}:{e.Value}"))] [requires (Select): using System.Linq]
Crystal: oMap.to_s
Excel: ___
Excel VBA: ___
Go: fmt.Sprintf("%v", oMap)
Java: oMap.toString()
JavaScript: [...oMap.entries()].join("\n") [WARNING (only prints a type name): String(oMap)] [WARNING (only prints a type name): oMap.toString()]
Kotlin: oMap.toString()
PHP: ___ [can use: var_export($oMap, true)] [also: print_r($oMap, true)]
Python: str(oDict)
R: paste(names(oMap), oMap, sep = ": ", collapse = ", ") [also (returns values only): toString(oMap)] [also: capture.output(print(oMap))]
Ruby: oMap.to_s
Rust: format!("{:?}", oMap) [also: format!("{:#?}", oMap)]
Scala: oMap.toString
Swift: String(describing:oDict) [also: oDict.description] [also: String(reflecting:oDict)] [also (sorted dict): String(describing:oDict.map{($0,$1)}.sorted(by:{e1,e2 in e1.0<e2.0}))]
UFL: (Map.ToIni) [map to ini file string]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: ___
Swift: ___
UFL: Map.CaseSense [set whether key names are case-sensitive/case-insensitive]
AutoHotkey: oMap.CaseSense := vMode
C++: ___
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: ___ [note: a related function: array_change_key_case(): 'Changes the case of all keys in an array']
Python: ___
R: ___
Ruby: ___
Rust: ___
Scala: ___
Swift: ___
Section: Object Methods
UFL: Object.Print [print the property-value pairs][see also: PrintKeyValue/Object.ToString]
AutoHotkey: ___
C++: ___
C#: Console.WriteLine(String.Join("\n", oObj)) [also: Console.WriteLine(String.Join("\n", (IDictionary<string,object>)oObj))]
Crystal: p oObj
Excel: ___
Excel VBA: ___
Go: fmt.Println(oObj) [WARNING: prints values but not property names] [also (print property names and types): fmt.Printf("%T\n", oObj)] [also: fmt.Printf("%T%[1]v\n", oObj)] [also: fmt.Printf("%#v\n", oObj)]
Java: for (Field f : oObj.getClass().getFields()) {try {System.out.println(f.getName() + " " + f.get(oObj));} catch (Exception e) {}} [requires: import java.lang.reflect.Field] [e.g. works with int/float/string values]
JavaScript: console.log(oObj) [also: console.log(JSON.stringify(oObj, null, 4))] [also: console.log(Object.entries(oObj).join("\n"))]
Kotlin: ___
PHP: var_export($oObj) [also: var_dump($oObj)] [also: print_r($oObj)]
Python: print(oObj)
R: print(oObj) [also: mapply(\(v) slot(oObj,v), slotNames(oObj))] [also: paste(slotNames(oObj), mapply(\(v) slot(oObj,v), slotNames(oObj)), sep = ": ", collapse = ", ")]
Ruby: p oObj
Rust: println!("{:?}", oObj) [also: println!("{:#?}", oObj)] [note: to print a struct instance via println, you must add '#[derive(Debug)]' above the struct definition]
Scala: for (f <- oObj.getClass.getDeclaredFields) {f.setAccessible(true); println((f.getName, f.get(oObj)))} [note: case class: outputs values: println(oObj)] [WARNING: non-case class: outputs type name: println(oObj)]
Swift: print(oObj)
UFL: Object.LoopPropValue [loop through the items of an object, get property-value pairs one-by-one]
AutoHotkey: for vProp, vValue in oObj.OwnProps()
C++: ___
C#: foreach (var oEntry in (IDictionary<string,object>)oObj) [note: oEntry.Key, oEntry.Value] [also (for anonymous type): foreach (var oEntry in oObj.GetType().GetProperties())] [note (for anonymous type): oEntry.Name, oEntry.GetValue(oObj)]
Crystal: ___ [note: information can be parsed from oObj.to_s]
Excel: ___
Excel VBA: ___
Go: ___ [can use: reflect.ValueOf(oObj)] [MAJOR WARNING: retrieving info may fail if field names don't start with capital letters (upper case)] [note: information can be parsed from fmt.Sprintf("%v", oObj) and fmt.Sprintf("%T", oObj)]
Java: for (Field oField : oObj.getClass().getFields()) [note: property/value: oField.getName(), oField.get(oObj)] [note: get()/set() must be within a try block] [requires: import java.lang.reflect.Field]
JavaScript: for (const [vProp, vValue] of Object.entries(oObj)) [also: for (var vProp in oObj)]
Kotlin: ___
PHP: foreach ($oObj as $vProp=>$vValue)
Python: for vProp, vValue in oObj.__dict__.items():
R: for(vProp in slotNames(oObj)) [note: vValue = slot(oObj, vProp)]
Ruby: for vProp, vValue in oObj.each_pair [also: vValue = oObj[:"#{vProp}"]] [also: for vValue in oObj] [afterwards: end]
Rust: ___
Scala: for (oField <- oObj.getClass.getDeclaredFields) [note: property/value: oField.getName, oField.get(oObj)]
Swift: for (vProp, vValue) in Mirror(reflecting:oObj).children
UFL: Object.ForEach [or Object.LoopForEach][call a function once for each item of an object][see also: Object.LoopPropValue/Object.ToMap]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___ [note: information can be parsed from oObj.to_s]
Excel: ___
Excel VBA: ___
Go: ___ [note: information can be parsed from fmt.Sprintf("%v", oObj) and fmt.Sprintf("%T", oObj)]
Java: ___ [see also: 'Object.ToMap']
JavaScript: ___ [can use: new Map(Object.entries(oObj)).forEach(oFunc)] [note: Func receives value/key/object]
Kotlin: ___
PHP: ___
Python: ___
R: for(vProp in slotNames(oObj)) {oFunc(vProp, slot(oObj, vProp))}
Ruby: oObj.each_pair{|p,v| oFunc.call(p,v)}
Rust: ___
Scala: ___ [see also: 'Object.ToMap']
Swift: ___
UFL: Object.NewEmpty [or Object.NewBasic][create an empty JavaScript-like object (dot notation e.g. 'vValue = oObj.MyProp', modify/add properties) for storing properties][can modify and add properties, unless stated]
AutoHotkey: oObj := {} [type: Object]
C++: ___ [can use: 'struct MyStructEmp' and a function body] [afterwards: MyStructEmp oObj] [note: can't add properties] [type: (custom)]
C#: dynamic oObj = new ExpandoObject() [note: can modify/add properties] [also (anonymous type: read-only: can't add/modify properties): e.g. var oObj = new {p1="v1", p2="v2", p3="v3"}] [requires (ExpandoObject): using System.Dynamic] [type: ExpandoObject] [type (anonymous type): e.g. <>f__AnonymousType0`3]
Crystal: ___ [e.g. record MyStructEmp] [afterwards: oObj = MyStructEmpEmp.new()] [note: can't add properties] [type: (custom) e.g. MyStructEmp]
Excel: ___
Excel VBA: ___
Go: ___ [e.g. oObj := struct{}{}] [type: struct {}]
Java: ___ [can use: 'public static class MyClass' and a function body with some 'public' properties] [afterwards: MyClass oObj = new MyClass()] [note: can't add properties] [type: (custom)]
JavaScript: oObj = {} [type: Object]
Kotlin: ___ [can use: 'data class MyDataClass' with a function body, then 'oObj = MyDataClass()'] [also (for a singleton): 'oSingleton = object' with a function body, then 'oSingleton.MyProp'] [note (for both): can't add properties] [type (data class): simple name: (custom), qualified name: null] [type (singleton): null]
PHP: $oObj = new stdClass() [type: object (class: stdClass)] [note: member access: uses '->', not '.']
Python: oObj = SimpleNamespace() [type: SimpleNamespace] [note: oObj.__dict__ returns a dict object] [requires: from types import SimpleNamespace]
R: ___ [note: setClass requires at least one slot]
Ruby: ___ [e.g. MyStructEmp = Struct.new("MyStructEmp")] [afterwards: oObj = MyStructEmp.new()] [note: can't add properties] [type: Class (e.g. MyStructEmp.class returns 'Class', MyStructEmp.superclass returns 'Struct')]
Rust: ___ [e.g. struct MyStructEmp {}] [afterwards: oObj = MyStructEmp {}] [note: can't add properties] [type: (custom)]
Scala: ___ [can use: class MyClass()] [afterwards: var oObj = new MyClass()] [type: (custom) e.g. MyClass]
Swift: ___ [e.g. struct MyStructEmp] [afterwards: oObj = MyStructEmp()] [note: can't add properties] [type: (custom)]
UFL: (Object.NewStrDemo) [initialise a JavaScript-like object with 3 items (or the nearest equivalent)]
AutoHotkey: oObj := {p1:"v1", p2:"v2", p3:"v3"}
C++: struct MyStruct {std::string p1="v1"; std::string p2="v2"; std::string p3="v3";} [afterwards: MyStruct oObj] [note: can't add properties]
C#: foreach (var oEntry in (new Dictionary<string,object>{{"p1","v1"},{"p2","v2"},{"p3","v3"}})) ((IDictionary<string,object>)oObj).Add(oEntry) [beforehand: dynamic oObj = new ExpandoObject()] [also (anonymous type: read-only: can't add/modify properties): var oObj = new {p1="v1", p2="v2", p3="v3"}] [requires (ExpandoObject): using System.Dynamic] [requires (Dictionary): using System.Collections.Generic]
Crystal: ___ [e.g. record MyStruct, p1 : String, p2 : String, p3 : String] [afterwards: oObj = MyStruct.new("v1", "v2", "v3")] [note: can't add properties] [MAJOR WARNING: Crystal forces property names to start with a lower-case letter]
Excel: ___
Excel VBA: ___
Go: ___ [e.g. oObj := struct {p1 string; p2 string; p3 string}{"v1", "v2", "v3"}]
Java: public static class MyClass {public String p1="v1", p2="v2", p3="v3";} [afterwards: MyClass oObj = new MyClass()] [note: can't add properties]
JavaScript: oObj = {p1:"v1", p2:"v2", p3:"v3"}
Kotlin: data class MyDataClass(var dummy:String="") {var p1="v1"; var p2="v2"; var p3="v3"} [afterwards: oObj = MyDataClass()] [note: can't add properties]
PHP: $oObj = (object)["p1"=>"v1", "p2"=>"v2", "p3"=>"v3"]
Python: oObj = SimpleNamespace(**{"p1":"v1", "p2":"v2", "p3":"v3"}) [requires: from types import SimpleNamespace]
R: ___ [e.g. MyStruct = setClass("MyStruct", slots = c(p1="character", p2="character", p3="character"))] [afterwards: oObj = MyStruct(p1="v1", p2="v2", p3="v3")]
Ruby: ___ [e.g. MyStruct = Struct.new("MyStruct", "p1", "p2", "p3")] [afterwards: oObj = MyStruct.new("v1", "v2", "v3")] [note: can't add properties]
Rust: ___ [e.g. struct MyStruct {p1:String, p2:String, p3:String}] [afterwards: oObj = MyStruct {p1:"v1".to_string(), p2:"v2".to_string(), p3:"v3".to_string()}] [note: can't add properties]
Scala: ___ [can use: class MyClass(var p1: String="v1", var p2: String="v2", var p3: String="v3")] [afterwards: var oObj = new MyClass()] [type: (custom) e.g. MyClass]
Swift: ___ [e.g. struct MyStruct {var p1="v1"; var p2="v2"; var p3="v3"}] [afterwards: oObj = MyStruct()] [note: can't add properties]
UFL: (Object.NewStrIntDemo) [initialise a JavaScript-like object with 3 items][see also: Tuple.NewDemo]
AutoHotkey: oObj := {p1:1, p2:2, p3:3}
C++: struct MyStruct {int p1=1; int p2=2; int p3=3;} [afterwards: MyStruct oObj] [note: can't add properties]
C#: foreach (var oEntry in (new Dictionary<string,object>{{"p1",1},{"p2",2},{"p3",3}})) ((IDictionary<string,object>)oObj).Add(oEntry) [beforehand: dynamic oObj = new ExpandoObject()] [also (anonymous type: read-only: can't add/modify properties): var oObj = new {p1=1, p2=2, p3=3}] [requires (ExpandoObject): using System.Dynamic] [requires (Dictionary): using System.Collections.Generic]
Crystal: ___ [e.g. record MyStruct, p1 : Int32, p2 : Int32, p3 : Int32] [afterwards: oObj = MyStruct.new(1, 2, 3)] [note: can't add properties] [MAJOR WARNING: Crystal forces property names to start with a lower-case letter]
Excel: ___
Excel VBA: ___
Go: ___ [e.g. oObj := struct {p1 int; p2 int; p3 int}{1, 2, 3}]
Java: public static class MyClass {public int p1=1, p2=2, p3=3;} [afterwards: MyClass oObj = new MyClass()] [note: can't add properties]
JavaScript: oObj = {p1:1, p2:2, p3:3}
Kotlin: data class MyDataClass(var dummy:String="") {var p1=1; var p2=2; var p3=3} [afterwards: oObj = MyDataClass()] [note: can't add properties]
PHP: $oObj = (object)["p1"=>1, "p2"=>2, "p3"=>3]
Python: oObj = SimpleNamespace(**{"p1":1, "p2":2, "p3":3}) [requires: from types import SimpleNamespace]
R: ___ [e.g. MyStruct = setClass("MyStruct", slots = c(p1="numeric", p2="numeric", p3="numeric"))] [afterwards: oObj = MyStruct(p1=1, p2=2, p3=3)]
Ruby: ___ [e.g. MyStruct = Struct.new("MyStruct", "p1", "p2", "p3")] [afterwards: oObj = MyStruct.new(1, 2, 3)] [note: can't add properties]
Rust: ___ [e.g. struct MyStruct {p1:i32, p2:i32, p3:i32}] [afterwards: oObj = MyStruct {p1:1, p2:2, p3:3}] [note: can't add properties]
Scala: ___ [can use: class MyClass(var p1: Int=1, var p2: Int=2, var p3: Int=3)] [afterwards: var oObj = new MyClass()] [type: (custom) e.g. MyClass]
Swift: ___ [e.g. struct MyStruct {var p1=1; var p2=2; var p3=3}] [afterwards: oObj = MyStruct()] [note: can't add properties]
UFL: (Object.OrderType) [insertion order, alphabetical order, 'random' order (unordered)][e.g. what order does a loop return]
AutoHotkey: ___ [item order: {}: alphabetical (case *insensitive*) (AHK v1: also case-insensitive)]
C++: ___
C#: ___ [item order: ExpandoObject (and anonymous type): insertion]
Crystal: ___ [item order: MyStruct: insertion]
Excel: ___
Excel VBA: ___
Go: ___ [item order: struct {}: insertion]
Java: ___ [item order: MyClass: insertion]
JavaScript: ___ [item order: {}: insertion]
Kotlin: ___
PHP: ___ [item order: stdClass: insertion]
Python: ___ [item order: SimpleNamespace: insertion]
R: ___ [item order: MyStruct: insertion]
Ruby: ___ [item order: MyStruct: insertion]
Rust: ___
Scala: ___ [item order: MyClass: insertion]
Swift: ___ [item order: Struct: insertion]
UFL: Object.PropNames [or Object.OwnPropNames/Object.Props/Object.OwnProps]
AutoHotkey: oProps := [oObj.OwnProps()*]
C++: ___
C#: var oProps = ((IDictionary<string,object>)oObj).Keys
Crystal: ___ [note: information can be parsed from oObj.to_s]
Excel: ___
Excel VBA: ___
Go: ___ [note: information can be parsed from fmt.Sprintf("%v", oObj) and fmt.Sprintf("%T", oObj)]
Java: ___ [see also: 'Object.ToMap']
JavaScript: oProps = Object.keys(oObj) [also: oProps = Object.getOwnPropertyNames(oObj)] [note (both): returns an array, not an iterator (unlike oArray.keys() and oMap.keys())]
Kotlin: ___
PHP: $oProps = array_keys(get_object_vars($oObj))
Python: oProps = list(oObj.__dict__) [also: oObj.__dict__.keys()]
R: oProps = slotNames(oObj)
Ruby: oProps = oObj.members [also: oProps = oObj.to_h.keys] [also: oProps = oObj.each_pair.map{|p,v|p}]
Rust: ___
Scala: ___ [see also: 'Object.ToMap']
Swift: oProps = Mirror(reflecting:oObj).children.map{$0.0!} [note: failed with $0]
UFL: Object.Values [or Object.OwnValues]
AutoHotkey: oValues := [oObj.OwnProps().Bind(&_,)*]
C++: ___
C#: var oValues = ((IDictionary<string,object>)oObj).Values
Crystal: ___ [note: information can be parsed from oObj.to_s]
Excel: ___
Excel VBA: ___
Go: ___ [note: information can be parsed from fmt.Sprintf("%v", oObj) and fmt.Sprintf("%T", oObj)]
Java: ___ [see also: 'Object.ToMap']
JavaScript: oValues = Object.values(oObj) [note: returns an array, not an iterator (unlike oArray.values() and oMap.values())]
Kotlin: ___
PHP: $oValues = array_values(get_object_vars($oObj))
Python: oValues = oObj.__dict__.values()
R: ___ [can use: oValues = unname(mapply(\(v) slot(oObj,v), slotNames(oObj)))]
Ruby: oValues = oObj.to_a [also: oValues = oObj.to_h.values]
Rust: ___
Scala: ___ [see also: 'Object.ToMap']
Swift: oValues = Mirror(reflecting:oObj).children.map{$1}
UFL: (Object.Entries) [or Object.ToEntries/Object.OwnEntries]
AutoHotkey: ___
C++: ___
C#: string[][] oEntries = ((IDictionary<string,object>)oObj).Select(e=>new[]{e.Key,(string)e.Value}).ToArray()
Crystal: ___ [note: information can be parsed from oObj.to_s]
Excel: ___
Excel VBA: ___
Go: ___ [note: information can be parsed from fmt.Sprintf("%v", oObj) and fmt.Sprintf("%T", oObj)]
Java: ___ [see also: 'Object.ToMap']
JavaScript: oEntries = Object.entries(oObj) [note: returns an array of arrays, not an iterator (unlike oArray.entries() and oMap.entries())]
Kotlin: ___
PHP: foreach (get_object_vars($oObj) as $vProp=>$vValue) array_push($oEntries, [$vProp, $vValue]) [beforehand: $oEntries = []]
Python: oEntries = oObj.__dict__.items()
R: oEntries = Map(c, names(oMap), oMap, USE.NAMES=FALSE) [beforehand: oMap = mapply(\(v) slot(oObj,v), slotNames(oObj))] [note: returns a list]
Ruby: oEntries = oObj.each_pair.to_a [also: oEntries = oObj.to_h.to_a] [note (both): returns an array of arrays]
Rust: ___
Scala: ___ [see also: 'Object.ToMap']
Swift: oEntries = Mirror(reflecting:oObj).children.map{[$0!,$1]}
UFL: Object.OwnPropCount [or Object.PropCount/Object.Count]
AutoHotkey: vCount := ObjOwnPropCount(oObj)
C++: ___ [can use (e.g. if all members of the same size, e.g. std::string): e.g. 'vCount = sizeof(oObj)/sizeof(std::string)', e.g. 'vCount = sizeof(MyStruct)/sizeof(std::string)']
C#: vCount = ((IDictionary<string,object>)oObj).Count
Crystal: ___ [note: information can be parsed from oObj.to_s]
Excel: ___
Excel VBA: ___
Go: ___ [note: information can be parsed from fmt.Sprintf("%v", oObj) and fmt.Sprintf("%T", oObj)]
Java: vCount = oObj.getClass().getFields().length
JavaScript: vCount = Object.keys(oObj).length [also: Object.getOwnPropertyNames(oObj).length]
Kotlin: ___
PHP: $vCount = count(get_object_vars($oObj)) [also: count((array)$oObj)]
Python: vCount = len(oObj.__dict__)
R: vCount = length(slotNames(oObj))
Ruby: vCount = oObj.length [also: vCount = oObj.size] [also: vCount = oObj.count]
Rust: ___
Scala: vCount = oObj.getClass().getDeclaredFields.length
Swift: vCount = Mirror(reflecting:oObj).children.count
UFL: Object.Has [or Object.HasOwn/HasOwnProp/HasOwnProperty][does object have property with property name]
AutoHotkey: vHasProp := oObj.HasOwnProp(vProp)
C++: ___
C#: vHasProp = ((IDictionary<string,object>)oObj).ContainsKey(vProp)
Crystal: ___ [note: information can be parsed from oObj.to_s]
Excel: ___
Excel VBA: ___
Go: ___ [note: information can be parsed from fmt.Sprintf("%v", oObj) and fmt.Sprintf("%T", oObj)]
Java: ___ [see also: 'Object.ToMap']
JavaScript: vHasProp = (vProp in oObj) [also: oObj.hasOwn(vProp)] [also: oObj.hasOwnProperty(vProp)] [note: '(vProp in oObj)' works on all properties, not just own properties]
Kotlin: ___
PHP: $vHasProp = property_exists($oObj, $vProp)
Python: vHasProp = vProp in oObj.__dict__ [inverse: vProp not in oObj.__dict__]
R: vHasProp = .hasSlot(oObj, vProp)
Ruby: vHasProp = oObj.members.include?(:"#{vProp}") [e.g. oObj.members.include?(:MyProp)] [also (alias): oObj.members.member?]
Rust: ___
Scala: ___ [see also: 'Object.ToMap']
Swift: vHasProp = (Mirror(reflecting:oObj).descendant(vProp) != nil)
UFL: (Object.GetDemo) [object get property value]
AutoHotkey: vValue := oObj.MyProp
C++: vValue = oObj.MyProp
C#: vValue = oObj.MyProp
Crystal: vValue = oObj.myProp
Excel: ___
Excel VBA: ___
Go: vValue := oObj.MyProp
Java: vValue = oObj.MyProp
JavaScript: vValue = oObj.MyProp
Kotlin: vValue = oObj.MyProp
PHP: $vValue = $oObj->MyProp
Python: vValue = oObj.MyProp
R: vValue = slot(oObj, "MyProp") [also: vValue = oObj@MyProp]
Ruby: vValue = oObj.MyProp
Rust: vValue = oObj.MyProp
Scala: vValue = oObj.MyProp
Swift: vValue = oObj.MyProp
UFL: Object.Get [or Object[Prop]][object get property value]
AutoHotkey: vValue := oObj.%vProp%
C++: ___ [e.g. vValue = oObj.MyProp]
C#: vValue = ((IDictionary<string,object>)oObj)[vProp] [note: may want to append '.ToString()']
Crystal: ___ [note: information can be parsed from oObj.to_s]
Excel: ___
Excel VBA: ___
Go: ___ [note: information can be parsed from fmt.Sprintf("%v", oObj) and fmt.Sprintf("%T", oObj)]
Java: ___ [see also: 'Object.ToMap']
JavaScript: vValue = oObj[vProp]
Kotlin: ___ [e.g. vValue = oObj.MyProp]
PHP: $vValue = $oObj->$vProp
Python: vValue = oObj.__dict__[vProp]
R: vValue = slot(oObj, vProp)
Ruby: vValue = oObj[:"#{vProp}"]
Rust: ___ [e.g. vValue = oObj.MyProp]
Scala: ___ [see also: 'Object.ToMap']
Swift: vValue = Mirror(reflecting:oObj).descendant(vProp)!
UFL: Object.GetOrDefault [if property non-existent/null, provide default (deviations from this are noted)]
AutoHotkey: ___
C++: ___
C#: vValue = ((IDictionary<string,object>)oObj)[vProp] ?? vDefault [note: may want to append '.ToString()'] [note: doesn't work: ((IDictionary<string,object>)oObj).GetValueOrDefault(vProp, vDefault)] [WARNING: ((IDictionary<string,object>)oObj)[vProp] throws if property doesn't exist]
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [see also: 'Object.ToMap']
JavaScript: vValue = oObj[vProp] ?? vDefault [note: returns default if value is null/undefined]
Kotlin: ___
PHP: $vValue = $oObj->$vProp ?? $vDefault
Python: vValue = oObj.__dict__.get(vProp, vDefault) [WARNING: returns None if value is None]
R: ___
Ruby: vValue = oObj.members.include?(:"#{vProp}") ? oObj[:"#{vProp}"] : vDefault
Rust: ___
Scala: ___ [see also: 'Object.ToMap']
Swift: vValue = Mirror(reflecting:oObj).descendant(vProp) ?? vDefault [WARNING: returns optional nil if value is optional nil] [note: returns default if key doesn't exist]
UFL: (Object.SetDemo) [object set property value]
AutoHotkey: oObj.MyProp := "MyValue"
C++: oObj.MyProp = "MyValue"
C#: oObj.MyProp = "MyValue"
Crystal: oObj = oObj.copy_with(myProp: "MyValue") [e.g. oObj = oObj.copy_with(myProp1: "MyValue1", myProp2: "MyValue2", myProp3: "MyValue3")
Excel: ___
Excel VBA: ___
Go: oObj.MyProp = "MyValue"
Java: oObj.MyProp = "MyValue"
JavaScript: oObj.MyProp = "MyValue"
Kotlin: oObj.MyProp = "MyValue"
PHP: $oObj->MyProp = "MyValue"
Python: oObj.MyProp = "MyValue"
R: slot(oObj, "MyProp") = "MyValue" [also: oObj@MyProp = "MyValue"]
Ruby: oObj.MyProp = "MyValue"
Rust: oObj.MyProp = "MyValue"
Scala: oObj.MyProp = "MyValue"
Swift: oObj.MyProp = "MyValue"
UFL: Object.Set [or Object[Prop]][object set property value]
AutoHotkey: oObj.%vProp% := vValue [also: oObj.DefineProp(vPropName, oDescriptor)] [e.g. oObj.MyProp := vValue]
C++: ___ [e.g. oObj.MyProp = vValue]
C#: ((IDictionary<string,object>)oObj)[vProp] = vValue [e.g. oObj.MyProp = vValue]
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___ [see also: 'Object.ToMap'] [note: to modify an existing value: oField.set(oObj, vValue)] [e.g. oObj.MyProp = vValue]
JavaScript: oObj[vProp] = vValue [e.g. oObj.MyProp = vValue]
Kotlin: ___ [e.g. oObj.MyProp = vValue]
PHP: $oObj->$vProp = $vValue [e.g. $oObj->MyProp = $vValue]
Python: oObj.__dict__[vProp] = vValue [e.g. oObj.MyProp = vValue]
R: slot(oObj, vProp) = vValue
Ruby: oObj[:"#{vProp}"] = vValue [e.g. oObj.MyProp = vValue]
Rust: ___ [e.g. oObj.MyProp = vValue]
Scala: ___ [see also: 'Object.ToMap'] [note: to modify an existing value: oField.set(oObj, vValue)] [e.g. oObj.MyProp = vValue]
Swift: ___ [e.g. oObj.MyProp = vValue]
UFL: (Object.ForcePush) [an object of arrays: append an item to an array, create the array if it doesn't exist][workaround: specify 'new array' as the default value][perhaps a better name exists, we're pushing to a key, not to the object itself][see also: Object.Default]
AutoHotkey: ___
C++: ___
C#: ___
Crystal: ___
Excel: ___
Excel VBA: ___
Go: ___
Java: ___
JavaScript: ___
Kotlin: ___
PHP: $oObj->$vProp[] = $vValue [beforehand: $oObj = new stdClass()] [WARNING: '$oObj->$vProp[] = $vValue' creates an array if it doesn't exist, and pushes]
Python: ___
R: ___
Ruby: (oObj[:"#{vProp}"] ||= []) << vValue [beforehand: oMap = {}] [WARNING: a||=b equivalent to a?a:a=b not a=a||b]
Rust: ___
Scala: ___
Swift: ___
UFL: (Object.Fill) [or Object.SetAll][set all properties to the same value]
AutoHotkey: ___
C++: ___
C#: ___ [can use: foreach (var p in ((IDictionary<string,object>)oObj).Keys.ToList()) ((IDictionary
T,U,v BiConsumer<T,U> accept T,U,R BiFunction<T,U,R> apply T,T,T BinaryOperator<T> apply T,U,b BiPredicate<T,U> test b BooleanSupplier getAsBoolean T,v Consumer<T> accept d,d,d DoubleBinaryOperator applyAsDouble d,v DoubleConsumer accept d,R DoubleFunction<R> apply d,b DoublePredicate test d DoubleSupplier getAsDouble d,i DoubleToIntFunction applyAsInt d,l DoubleToLongFunction applyAsLong d,d DoubleUnaryOperator applyAsDouble T,R Function<T,R> apply i,i,i IntBinaryOperator applyAsInt i,v IntConsumer accept i,R IntFunction<R> apply i,b IntPredicate test i IntSupplier getAsInt i,d IntToDoubleFunction applyAsDouble i,l IntToLongFunction applyAsLong i,i IntUnaryOperator applyAsInt l,l,l LongBinaryOperator applyAsLong l,v LongConsumer accept l,R LongFunction<R> apply l,b LongPredicate test l LongSupplier getAsLong l,d LongToDoubleFunction applyAsDouble l,i LongToIntFunction applyAsInt l,l LongUnaryOperator applyAsLong o,d,v ObjDoubleConsumer<T> accept o,i,v ObjIntConsumer<T> accept o,l,v ObjLongConsumer<T> accept T,b Predicate<T> test T Supplier<T> get T,U,d ToDoubleBiFunction<T,U> applyAsDouble T,d ToDoubleFunction<T> applyAsDouble T,U,i ToIntBiFunction<T,U> applyAsInt T,i ToIntFunction<T> applyAsInt T,U,l ToLongBiFunction<T,U> applyAsLong T,l ToLongFunction<T> applyAsLong T,T UnaryOperator<T> apply The most general of the function types above that don't return a value: T,v Consumer<T> accept T,U,v BiConsumer<T,U> accept The most general of the function types above that do return a value: T Supplier<T> get T,R Function<T,R> apply T,U,R BiFunction<T,U,R> apply
Here's code for a custom interface, to create anonymous functions that take 3 parameters:
//place import and custom interface at the top:
import java.util.function.*;
@FunctionalInterface
interface MyTriFunction<A,B,C,R>
{
R apply(A a, B b, C c);
}
//define and call anonymous function in the body:
MyTriFunction<Integer,Integer,Integer,Integer> MyAdd3 = (vNum1, vNum2, vNum3) -> vNum1 + vNum2 + vNum3;
System.out.println(MyAdd3.apply(1,2,3)); //6