[Calculate:]

Performs a calculation.


Purpose

This is used to calculate a result based on other macros and calculations.


Compatibility

The macro can be used in all input document types and in Report Studio.


Usage

NCalc is used for expression evaluation (see NCalc documentation for built-in functions). In addition, the PanoramicData.NCalcExtensions library provides many additional functions - see the README for the full list. Note: Because ReportMagic uses commas to delimit parameters, either surround the condition with quotes or use backticks(`) instead of commas where needed. For example:

[Calculate:value="if(1<=2, 'AAA', 'BBB')"]
Note that you can use the shorthand for this macro i.e. '[=:' instead of '[Calculate:'. Some commonly used extension functions are shown below (this is not an exhaustive list):
  • if(condition, trueValue, falseValue): returns one of two values depending on the condition
  • in('needle', 'straw1', 'straw2', ...): returns true if the first value appears in the remaining values; also accepts a list variable as the second argument
  • contains('haystack', 'needle'): returns true if the haystack string contains the needle
  • startsWith / endsWith('haystack', 'needle'): string prefix/suffix tests
  • indexOf / lastIndexOf('haystack', 'needle'): returns the integer offset, or -1 if not found
  • length('string'): returns the integer length of the string or list
  • toUpper / toLower / capitalize('string'): case conversion
  • replace('input', 'find', 'replacement'): replaces all occurrences of a string
  • substring('string', startIndex, length): extracts part of a string
  • split('string', 'delimiter'): splits a string into a list
  • trim('string'): removes leading and trailing whitespace
  • timeSpan('fromDate', 'toDate', 'unit'): time between two dates in the given unit (Milliseconds, Seconds, Minutes, Hours, Days, Weeks, Years)
  • dateAdd('date', amount, 'unit'): adds an interval to a DateTime
  • now('timezone'): the current date/time, with optional timezone correction
  • humanize(value, 'timeUnit'): converts a numeric duration to readable text e.g. humanize(1.5, 'days') = '1 day 12 hours'
  • isNaN / isInfinite / isNull / isNullOrEmpty(value): value type/state tests
  • list(items): creates a list; jObject(key, value, ...): creates a JSON object; jArray(items): creates a JSON array
  • where(list, 'x', 'condition'): filters a list; select(list, 'x', 'expression'): transforms a list
  • orderBy(list, 'x', 'expression'): sorts a list; first / last / skip / take: list navigation
  • count(list) / sum(list) / min(list) / max(list): list aggregates
  • countBy(list, 'x', 'expression'): groups and counts into a JObject
  • jPath(obj, 'path'): selects a value from a JObject using a JPath expression
  • getProperty(obj, 'name'): returns a property value from an object
  • regexIsMatch('input', 'pattern'): tests a regex match; regexGroup('input', 'pattern', group): captures a group
  • nullCoalesce(a, b, ...): returns the first non-null value
  • try(expression, fallback): returns fallback if the expression throws
  • switch(value, case1, result1, ..., default): multi-branch conditional
  • round(value, decimalPlaces): rounds a number (see examples, below)

Note: The value will be stored in output variables (e.g. using storeAs, storeAsHidden or the '=>' shorthand) as the original type and at full precision. For example, if you output a DateTime, the full precision will be stored, including hours, minutes and seconds. For an integer of 12345, the integer value will be stored. However, the value output into the document must formatted as a string. The conversion from original output to string is achieved using the format parameter and the way in which this happens will depend on the type of the output. For example, the output of a DateTime written to the document might be '2023-02-17'. The integer may be formatted as '12,345'. If you would like to additionally store the formatted string to a variable, use the storeFormattedValueAs parameter.

.


Updates

2 years ago · September 2024

Help now includes the jArray() function and includes an example.


Parameters (92)
Mandatory (1)
Parameter TypePurpose Options Default
value
StringAn expression to calculate. May use variables previously calculated and stored using storeAs / storeAsHidden. All functions supported by NCalc are supported, as well as some additional functions (see below). N/A N/A
Behaviour (11)
Parameter TypePresencePurpose Options Default
calculate
StringOptionalPost processing formula. Use {value} to substitute the macro's output into the formula as text, e.g. {value}/1024, or the bare word value to use the output itself, e.g. jPath(value, 'id') to read a property from an object. If the result is fractional it is shown to two decimal places unless you also set format, e.g. format=G to show it in full; a value kept by storeAs always retains its full precision. N/A N/A
desiredExecutionResult
List<ExecutionResult>OptionalIf specified, asserts the expected execution result of the macro. Accepts a single value or a semicolon-separated list of acceptable values (e.g. 'Success;Warning'). The macro executes normally; if the actual result matches any of the desired values, the result is converted to Success. If the actual result does not match, the result is converted to MacroError with a descriptive message. This is primarily used for testing and diagnostic purposes. Valid values are: 'Unknown', 'Success', 'MacroError', 'WorkerStopped', 'Running', 'Warning', 'NeverRun', 'Cancelled', 'Pending', 'Paused', 'SystemError', 'Deferred' and 'Stopped'.
  • Cancelled
  • Deferred
  • MacroError
  • NeverRun
  • Paused
  • Pending
  • Running
  • Stopped
  • Success
  • SystemError
  • Warning
  • WorkerStopped
N/A
errorOnOverflow
BooleanOptionalShould NCalc expression evaluation throw error on Overflow
  • true
  • false
true
expectedType
StringOptionalIf specified, asserts the expected output type of the macro result. The macro executes normally; if the actual type does not match, a macro error is generated. Requires 'storeAs', 'storeAsHidden', or 'storeFormattedValueAs' to be set for typed validation. Valid types include CLR names (e.g. Int32, Int64, Single, Double, Boolean, String, JArray, JObject) and C# keyword aliases (e.g. int, long, float, double, bool, string, uint, ulong, short, ushort, byte, sbyte, decimal, char, object). The special value 'Number' matches any numeric type. N/A N/A
expectedValue
StringOptionalIf specified, asserts the expected output value of the macro result. The macro executes normally; if the actual value does not match, a macro error is generated. When 'storeAs' or 'storeAsHidden' is set, the stored variable value is compared. Otherwise, the document output text is compared. N/A N/A
hidden
BooleanOptionalWhether to hide the macro output.
  • true
  • false
false
if
StringOptionalThe condition that must be true in order for the macro to be executed/evaluated. Must either evaluate to true or false, for example: "3+5=8" or "contains('abcd', 'z')". N/A true
mode
MacroModeOptionalThe mode in which variables are stored. In legacy mode (default for Schedules), the variable created is a string and formatted. In normal mode (default for Report Studio), the output variable is stored as a strongly-typed object, e.g. an Int32 or a JArray etc., rather than a formatted string.
  • Legacy
  • Normal
Legacy
obfuscation
ObfuscationTypeOptionalObfuscation type. Use obfuscation to write reports where sensitive data is hidden. When used, ReportMagic guarantees that the same input string will map to the same output string for the whole of the report (but the next time the report runs, it will most likely map to a different value). If you use obfuscation, the property in your macro will not show up and instead, you will see a fake item of the obfuscation type chosen.
  • None
  • UkTown
  • DeviceName
  • Company
  • IpAddress
  • PrivateIpAddress
None
redact
BooleanOptionalWhether substituted variables are hidden from macro results (and the word 'REDACTED' will appear in progress screens and elsewhere in the web UI).
  • true
  • false
false
warning
StringOptionalIf specified, adds a warning message for this macro. This is processed as an NCalc, and the warning message will ALWAYS be present and will be the value of the evaluated NCalc expression. N/A N/A
Colours (18)3 additional
Parameter TypePresencePurpose Options Default
criticalFontBackgroundColor
ColorOptionalThe critical font background color to use. If omitted, no change is made. N/A
criticalFontColor
ColorOptionalThe critical font color to use. If omitted, no change is made. N/A
criticalTableCellBackgroundColor
ColorOptionalThe critical table cell background color to use. If omitted, no change is made. N/A
errorFontBackgroundColor
ColorOptionalThe error font background color to use. If omitted, no change is made. N/A
errorFontColor
ColorOptionalThe error font color to use. If omitted, no change is made. N/A
errorTableCellBackgroundColor
ColorOptionalThe error table cell background color to use. If omitted, no change is made. N/A
fatalFontBackgroundColor
ColorOptionalThe fatal font background color to use. If omitted, no change is made. N/A
fatalFontColor
ColorOptionalThe fatal font color to use. If omitted, no change is made. N/A
fatalTableCellBackgroundColor
ColorOptionalThe fatal table cell background color to use. If omitted, no change is made. N/A
infoFontBackgroundColor
ColorOptionalThe info font background color to use. If omitted, no change is made. N/A
infoFontColor
ColorOptionalThe info font color to use. If omitted, no change is made. N/A
infoTableCellBackgroundColor
ColorOptionalThe info table cell background color to use. If omitted, no change is made. N/A
normalFontBackgroundColor
ColorOptionalThe normal font background color to use. If omitted, no change is made. N/A
normalFontColor
ColorOptionalThe normal font color to use. If omitted, no change is made. N/A
normalTableCellBackgroundColor
ColorOptionalThe normal table cell background color to use. If omitted, no change is made. N/A
warningFontBackgroundColor
ColorOptionalThe warning font background color to use. If omitted, no change is made. N/A
warningFontColor
ColorOptionalThe warning font color to use. If omitted, no change is made. N/A
warningTableCellBackgroundColor
ColorOptionalThe warning table cell background color to use. If omitted, no change is made. N/A
Additional (3)
Parameter TypePresencePurpose Options Default
colorTableCell
BooleanOptionalWhether to color table cells if thresholds are breached, rather than color the text.
  • true
  • false
true
fontBackgroundColor
ColorOptionalThe font background color to use. N/A
fontColor
ColorOptionalThe font color to use. N/A
Formatting (12)3 additional
Parameter TypePresencePurpose Options Default
criticalFontBold
BooleanOptionalChange the critical font weight (true=strong, false=normal). If omitted, no change is made.
  • true
  • false
N/A
criticalFontSize
DoubleOptionalChange the critical font size in points. If omitted, no change is made.
  • From 2 to 200
N/A
errorFontBold
BooleanOptionalChange the error font weight (true=strong, false=normal). If omitted, no change is made.
  • true
  • false
N/A
errorFontSize
DoubleOptionalChange the error font size in points. If omitted, no change is made.
  • From 2 to 200
N/A
fatalFontBold
BooleanOptionalChange the fatal font weight (true=strong, false=normal). If omitted, no change is made.
  • true
  • false
N/A
fatalFontSize
DoubleOptionalChange the fatal font size in points. If omitted, no change is made.
  • From 2 to 200
N/A
infoFontBold
BooleanOptionalChange the info font weight (true=strong, false=normal). If omitted, no change is made.
  • true
  • false
N/A
infoFontSize
DoubleOptionalChange the info font size in points. If omitted, no change is made.
  • From 2 to 200
N/A
normalFontBold
BooleanOptionalChange the normal font weight (true=strong, false=normal). If omitted, no change is made.
  • true
  • false
N/A
normalFontSize
DoubleOptionalChange the normal font size in points. If omitted, no change is made.
  • From 2 to 200
N/A
warningFontBold
BooleanOptionalChange the warning font weight (true=strong, false=normal). If omitted, no change is made.
  • true
  • false
N/A
warningFontSize
DoubleOptionalChange the warning font size in points. If omitted, no change is made.
  • From 2 to 200
N/A
Additional (3)
Parameter TypePresencePurpose Options Default
fontBold
BooleanOptionalChange the font weight (true=strong, false=normal). If omitted, no change is made.
  • true
  • false
N/A
fontSize
DoubleOptionalChange the font size in points. If omitted, no change is made.
  • From 2 to 200
N/A
format
StringOptionalThe formatting to use for numbers. You can also specify 'format=string' to force numbers to be treated as strings. For dates, C# date formats are supported, plus two special values (in any casing): 'format=dayOfWeek' for the day of the week as a number (Sunday = 0; use 'format=dddd' for the day name) and 'format=epoch' for the number of seconds since 1970-01-01 UTC. N/A N/A
Conditional Formatting (35)
Parameter TypePresencePurpose Options Default
criticalEq
StringOptionalThe macro is considered 'critical' if the output is equal to this value. N/A N/A
criticalGe
StringOptionalThe macro is considered 'critical' if the output is greater than or equal to this value. N/A N/A
criticalGt
StringOptionalThe macro is considered 'critical' if the output is greater than this value. N/A N/A
criticalIf
StringOptionalThe macro is considered 'critical' if the expression evaluates to true. Use 'value' as the macro output in the expression. N/A N/A
criticalLe
StringOptionalThe macro is considered 'critical' if the output is less than or equal to this value. N/A N/A
criticalLt
StringOptionalThe macro is considered 'critical' if the output is less than this value. N/A N/A
criticalNe
StringOptionalThe macro is considered 'critical' if the output is not equal to this value. N/A N/A
errorEq
StringOptionalThe macro is considered 'error' if the output is equal to this value. N/A N/A
errorGe
StringOptionalThe macro is considered 'error' if the output is greater than or equal to this value. N/A N/A
errorGt
StringOptionalThe macro is considered 'error' if the output is greater than this value. N/A N/A
errorIf
StringOptionalThe macro is considered 'error' if the expression evaluates to true. Use 'value' as the macro output in the expression. N/A N/A
errorLe
StringOptionalThe macro is considered 'error' if the output is less than or equal to this value. N/A N/A
errorLt
StringOptionalThe macro is considered 'error' if the output is less than this value. N/A N/A
errorNe
StringOptionalThe macro is considered 'error' if the output is not equal to this value. N/A N/A
fatalEq
StringOptionalThe macro is considered 'fatal' if the output is equal to this value. N/A N/A
fatalGe
StringOptionalThe macro is considered 'fatal' if the output is greater than or equal to this value. N/A N/A
fatalGt
StringOptionalThe macro is considered 'fatal' if the output is greater than this value. N/A N/A
fatalIf
StringOptionalThe macro is considered 'fatal' if the expression evaluates to true. Use 'value' as the macro output in the expression. N/A N/A
fatalLe
StringOptionalThe macro is considered 'fatal' if the output is less than or equal to this value. N/A N/A
fatalLt
StringOptionalThe macro is considered 'fatal' if the output is less than this value. N/A N/A
fatalNe
StringOptionalThe macro is considered 'fatal' if the output is not equal to this value. N/A N/A
infoEq
StringOptionalThe macro is considered 'info' if the output is equal to this value. N/A N/A
infoGe
StringOptionalThe macro is considered 'info' if the output is greater than or equal to this value. N/A N/A
infoGt
StringOptionalThe macro is considered 'info' if the output is greater than this value. N/A N/A
infoIf
StringOptionalThe macro is considered 'info' if the expression evaluates to true. Use 'value' as the macro output in the expression. N/A N/A
infoLe
StringOptionalThe macro is considered 'info' if the output is less than or equal to this value. N/A N/A
infoLt
StringOptionalThe macro is considered 'info' if the output is less than this value. N/A N/A
infoNe
StringOptionalThe macro is considered 'info' if the output is not equal to this value. N/A N/A
warningEq
StringOptionalThe macro is considered 'warning' if the output is equal to this value. N/A N/A
warningGe
StringOptionalThe macro is considered 'warning' if the output is greater than or equal to this value. N/A N/A
warningGt
StringOptionalThe macro is considered 'warning' if the output is greater than this value. N/A N/A
warningIf
StringOptionalThe macro is considered 'warning' if the expression evaluates to true. Use 'value' as the macro output in the expression. N/A N/A
warningLe
StringOptionalThe macro is considered 'warning' if the output is less than or equal to this value. N/A N/A
warningLt
StringOptionalThe macro is considered 'warning' if the output is less than this value. N/A N/A
warningNe
StringOptionalThe macro is considered 'warning' if the output is not equal to this value. N/A N/A
Output (7)
Parameter TypePresencePurpose Options Default
failureText
StringOptionalThe text to display should the macro fail to execute. Note that a poorly-specified macro (e.g. omitting mandatory parameters) will still result in an error message. N/A N/A
failureVariable
StringOptionalThe name of a variable to create should the macro fail to execute. The variable will be a text variable, and will contain either the failure text (only if the failureText parameter is set), otherwise it will contain the exception / failure message. N/A N/A
outputListsAsJarray
Normal mode
BooleanOptionalAny macros that output lists can optionally (in Normal mode) output a jArray instead.
  • true
  • false
true
storeAs
StringOptionalThe variable to store the result as. If the variable name ends 'Json' (any casing) its value is wrapped in json tags. That marks the value as JSON so it can be passed straight into a parameter that expects json content, and the RMScript editor also displays it with JSON highlighting. When several variables are stored at once each one is judged by its own name. N/A N/A
storeAsHidden
StringOptionalThe variable to store the result as, while hiding the output. Equivalent to 'storeAs=ThisValue, hidden=true'. N/A N/A
storeAsVariableDelimiter
CharOptionalThe delimiter used by storeAs to split a TEXT value, when there are multiple stored variables. For example, in this macro, we indicate that the value to be stored should be split by the asterisk when being stored: [String:value=a*b*c*d, storeAs=var1;var2;var3;var4, storeAsVariableDelimiter=*]. If splitting on this delimiter does not produce one value per variable, the '^' character is tried instead; that applies whatever this parameter is set to, and is what allows a single variable to hold a value containing a ';'. Note this delimiter is only used for a TEXT value. A list or a JSON array is instead shared out one element per variable, and a JSON object by its property values in order, so storing jObject('a',1,'b',2) as two variables gives 1 and 2. Any other type cannot be split across several variables at all. N/A ;
storeFormattedValueAs
StringOptionalThe name of the STRING variable to store the result as and output (both will use the same format) into the report. Note that if you also use 'storeAsHidden' in the same macro, you should not expect the output to be hidden, as this parameter overrides that. As with 'storeAs', a name ending 'Json' has its value wrapped in json tags. N/A N/A
General (1)2 additional
Parameter TypePresencePurpose Options Default
value
StringMandatoryAn expression to calculate. May use variables previously calculated and stored using storeAs / storeAsHidden. All functions supported by NCalc are supported, as well as some additional functions (see below). N/A N/A
Additional (2)
Parameter TypePresencePurpose Options Default
comment
StringOptionalAdd a comment to make your document template more readable. The comment is discarded in the output document. N/A N/A
singleValueList
Normal mode
BooleanOptionalIn Normal Mode and for macros that output JArrays only, whether to convert a JArray of single-property jObjects into a flat JArray of values.
  • true
  • false
false

Examples (44)

Example 1
[Calculate: value=1, storeAs=a]
Outputs: 1

Example 2
[Calculate: value=2, storeAs=b][Calculate: value=3, storeAs=c]
Outputs: 23

Example 3
[Calculate: value=3+5, storeAs=c]
Outputs: 8

Example 4
[Calculate: value=1, storeAsHidden=a] [Calculate: value=2, storeAsHidden=b] [Calculate: value=3, storeAsHidden=c] [Calculate: value=({a}+{b})/{c}, errorGe=0.01, format=N2]

Example 5
[Calculate: value=1, storeAsHidden=a] [Calculate: value=2, storeAsHidden=b] [Calculate: value=3, storeAsHidden=c] [Calculate: value="if({a}={b},1,2)", errorGe=0.01, format=N2]

Example 6
[Calculate: value=1, storeAsHidden=a] [Calculate: value=2, storeAsHidden=b] [Calculate: value=3, storeAsHidden=c] [Calculate: value="if({b}>{a},'OK','Not OK')"]

Example 7
[Calculate: value=5+3, storeAsHidden=Result] [Calculate: value={Result}, warningGe=2, warningFontColor=Orange, warningFontBackgroundColor=#ddd, warningFontBold=True, warningFontSize=20, errorGe=4, errorFontColor=Blue, errorFontBackgroundColor=Yellow, errorFontBold=True, errorFontSize=50]

Example 8
[Calculate: value="contains('haystack containing needle', 'needle')"]
Outputs: True

Example 9
[Calculate: value="startsWith('haystack containing needle', 'needle')"]
Outputs: False

Example 10
[Calculate: value="endsWith('haystack containing needle', 'needle')"]
Outputs: True

Example 11
[Calculate: value="indexOf('haystack containing a needle and another needle', 'needle')"]
Outputs: 22

Example 12
[Calculate: value="lastIndexOf('haystack containing a needle and another needle', 'needle')"]
Outputs: 41

Example 13
[Calculate: value="lastIndexOf('haystack containing no sharp pointy things', 'needle')"]
Outputs: -1

Example 14
[Calculate: value="length('haystack containing needle')"]
Outputs: 26

Example 15
[Calculate: value="in(1, 1, 2, 3)"]
Outputs: True

Example 16
[Calculate: value="in(99, 1, 2, 3)"]
Outputs: False

Example 17
[Calculate: value="isNaN(1/2)"]
Outputs: False

Example 18
[Calculate: value="isNaN(1/0)", errorOnOverflow=false]
Outputs: False

Example 19
[Calculate: value="isInfinite(1/2)"]
Outputs: False

Example 20
[Calculate: value="isInfinite(1/0)", errorOnOverflow=false]
Outputs: True

Example 21
[Calculate: value="isInfinite(-1/0)", errorOnOverflow=false]
Outputs: True

Example 22
[Calculate: value="if(in(1, 1, 2, 3), 'Passed', 'Failed')"]
Outputs: Passed

Example 23
[Calculate: value="timeSpan('1975-02-17', '2017-02-17', 'Days')"]
Outputs: 15341

Example 24
[Calculate: value="timeSpan('1975-02-17 16:00', '2017-02-17 17:00', 'Hours')"]
Outputs: 368185

Example 25
[Calculate: value="toUpper('aBc def')"]
Outputs: ABC DEF

Example 26
[Calculate: value="toLower('aBc def')"]
Outputs: abc def

Example 27
[Calculate: value="capitalise('aBc def')"]
Outputs: Abc def

Example 28
[Calculate: value="if(2.368475785867E-16 < 0`'-ve'`if(2.368475785867E-16 < 0.01`'<0.01'`2.368475785867E-16))"]
Outputs: <0.01

Example 29
[Calculate: value="Round(12.34, 0)", format=F0]
Outputs: 12

Example 30
[Calculate: value="Round(12.34, 1)", format=F1]
Outputs: 12.3

Example 31

Calculate and store the value 12.34 into a variable (at 1 decimal place precision), and DISPLAY at 1 decimal place too by using the 'format' parameter:

[Calculate: value="Round(12.34, 1)", format=F1, storeAs=Output]
Outputs: 12.3

Example 32

Calculate and store the value 12.34 into a variable (at 1 decimal place precision), but DISPLAY at 1 decimal place (by omitting the 'format' parameter):

[Calculate: value="Round(12.34, 1)", storeAs=Output]
Outputs: 12.30

Example 33
[Calculate: value="humanize(0.25, 'days')"]
Outputs: 6 hours

Example 34
[Calculate: value="humanize(24, 'hours')"]
Outputs: 1 day

Example 35

Stores what you can see in ReportStudio (to 2 decimal places) as the variable B and stores the hidden output (to 0 decimal places) in A.

[Calculate: value="Round(12.34, 0)", storeAs=A, storeFormattedValueAs=B]<br/>A is '[String: value={A}]' and B is '[String: value ={B}]'
Outputs: 12:00
A is '12' and B is '12.00'

Example 36

You can create JObjects directly and access the values using the [.:] shorthand. Note this example uses the Calculate macro shorthand i.e. starts with '[=:' instead of '[Calculate:]' :

[=:`jObject('v', null, 'w', 'Some text', 'y', jObject('z', 1))`, =>x][.:x.y.z]
Outputs: 1

Example 37

This example creates a jArray:

[=:`list(1, 2, 3, 4, 5)`, =>MyList]

Example 38

This example creates a jArray:

[=:`jArray(jObject('a', 1, 'b', null), jObject('a', 2, 'b', dateTime('UTC', '2024-06-21T00:00:00')))`, =>jArray]
Outputs: [ { "a" : 1, "b" : null }, { "a" : 2, "b" : "2024-06-21T00:00:00" } ]

Example 39

This example creates a string URL and uses the Calculate macro shorthand i.e. starts with '[=:' instead of '[Calculate:]' :

[=:'https://en.wikipedia.org/wiki/Alphabet', =>CustomerUrl1]
Outputs: https://en.wikipedia.org/wiki/Alphabet

Example 40

This example creates a string URL and uses the Calculate macro shorthand i.e. starts with '[=:' instead of '[Calculate:]' :

[=:'http://www.google.com/', =>CustomerUrl2]
Outputs: http://www.google.com/

Example 41

Counts the number of characters in a string

[Calculate: value="count('Report Magic')"]
Outputs: 12

Example 42

Counts the number of characters in a string

[Calculate: value="count('ReportMagic')"]
Outputs: 11

Example 43

Counts by how many of each number there are in a list, i.e. grouped by the values themselves, and stores the results as a new JObject (dictionary) variable:

[Calculate: value="countBy(list(1, 1, 1, 1, 1, 2, 2, 3, 3, 3, 4), 'n', 'toString(n)')", =>Count]
Outputs: { "1" : 5, "2" : 2, "3" : 3, "4" : 1 }

Example 44Normal mode

This Normal Mode example counts 'Tickets' grouped by their name and stores the result as a new jObject (dictionary) variable:

// First create a list of JObjects: [Calculate: value="list( jObject('name', 'A', 'description', 'yaaay'), jObject('name', 'B', 'description', 'houpla'), jObject('name', 'C', 'description', 'woowoo'), jObject('name', 'C', 'description', 'yay'), jObject('name', 'B', 'description', 'woo'), jObject('name', 'B', 'description', 'blah') )", mode=Normal, =>Tickets] // Now calculate how many there are for each of the name properties, i.e how many are called 'A', 'B', and so on: [Calculate: value="countBy(Tickets, 'n', 'getProperty(n, \'name\')')", mode=Normal, =>Output]
Outputs: { "A" : 1, "B" : 3, "C": 2 }

Reconnection

Reconnection

Reconnection

timed out

timed out

Attempt of

Reload
An unhandled error has occurred. Reload 🗙