Page Comparison

Quino einthält eine einfache Sprache für Ausdrücke welche innerhalb der Applikation verwendet werden kann um Filter oder Bedingungn zu erstellen. Es ist auch Möglich Werte aus dem Daten Kontext und von Funktionen zu zuzugreifen. (context data and functions.)

Table of Contents

Basistypen

Type	Beispiel	XML
Ganze Zahlen	`6`
Dezimalzahlen	`45.678` oder `45.678f`
Dezimalzahlen (hohe Präzision)	`45.678m`
null - Konstante	`null`
Boolsche - Konstanten	`true`, `false`
Einfache Zeichenkette mit ''	`'A ''quoted'' string'`
Alternative Zeichenkette mit ““	`"A \"quoted\" string"`	Nicht zulässig. Hier müssen die einfachen Hochkommas verwendet werden.
Liste	`[A, B, 2, "three"]`

Operatoren

Vergleichsoperatoren

Die folgenden Operatoren vergleichen zwei Werte. Die Operatoren machen am meisten Sinn für numerische Vergleiche. Jedoch sind auch Vergleiche mit anderen Typen möglich.

Operator	XML	Beschreibung	Beispiel	Resultat
`==`		Gleich	`2 == 2`	Wahr
`!=`		Nicht gleich	`2 != 2`	Falsch
`>`	`>`	Grösser als	`2 > 2`	Falsch
`<`	`<`	Kleiner als	`2 < 2`	Falsch
`>=`	`>=`	Grösser als oder gleich	`2 >= 2`	Wahr
`<=`	`<=`	Kleiner als oder gleich	`2 <= 2`	Wahr

String Operatoren

Die folgenden Operatoren können für Zeichenketten verwendet werden:. CI referenziert dabei auf Case Insensitive. Die anderen Methoden berücksichtigten Gross-/Kleinschreibung.

Operator	Synonym	Beschreibung	Beispiel	Resultat
`%=`	`BeginsWith()`	Startet mit	`'bla' %= 'b'`	Wahr
`=%`	`EndsWith()`	Endet mit	`'bla' =% 'a'`	Wahr
`%=%`	`Contains()`	enthält	`'bla' %=% 'la'`	Wahr
`~~`	`EqualsCI()`	Gleich*	`'bla' ~~ 'Bla'`	Wahr
`!~`	`NotEqualsCI()`	Nicht gleich*	`'bla' !~ 'Bla'`	Falsch
`%~`	`BeginsWithCI()`	Startet mit*	`'bla' %= 'B'`	Wahr
`~%`	`EndsWithCI()`	Endet mit*	`'bla' =% 'A'`	Wahr
`%~%`	`ContainsCI()`	Enthält*	`'bla' %=% 'LA'`	Wahr

...

Arithmetische Operatoren

Für arithmetische Funktionen stehen folgende Operatoren zur Verfügung:

Operator	Beschreibung	Typen	Beispiel	Resultat
`*`	Multiplikation	Numerisch	`2 * 2`	4
`/`	Division	Numerisch	`2 / 2`	1
`+`	Addition	Numerisch, DateTime, TimeSpan	`2 + 2`	4
`-`	Subtraktion	Numerisch, DateTime, TimeSpan	`2 - 2`	0
`^`	Potenz	Numerisch	`2 ^ 3`	8
`%`	Modulo	Numerisch	`3 % 2`	1

Boolsche Operatoren

Folgende “verbindende” Operatoren stehen zur Verfügung:

Operator	XML	Beschreibung	Beispiel	Resultat
`&&`	`&&`	und	`true && false`	Falsch
`\|\|`		oder	`true \|\| false`	Wahr
`!`		nicht	`!true`	Falsch

Regular Expressions

Operator	Synonym	Beschreibung	Beispiel	Resultat
`=@`	`Matches()`	matches regular expression	`'bla' =@ 'b*'`	true
`~@`	`MatchesCI()`	matches regular expression CI	`'bla' ~@ 'B*'`	true

See regular expressions for more information.

Null-handling

Use the following operators to test for and handle null values.

Operator	Synonym	Beschreibung	Typen	Beispiel	Resultat
`?`	`IsNull()`	unary IS NULL	Any	?null	true
`!?`	`IsNotNull()`	unary IS NOT NULL	Any	!?null	false
`??`	`Coalesce()`	Null-coalescing	Any	null ?? 2	2

Type-casting

The type-cast operator allows an application to transform the type directly. Any number with a decimal point is automatically a floating-point number. Use the m suffix to make it the money type instead. For some other common types, there are standard functions that are more flexible than type-casting (see custom dates and time functions and custom Guid functions).

Operator	Beschreibung	Typen	Beispiel	Resultat
`()`	Type-cast	Typename, Any	(int)value	value (w/type 'int')

A product can create expressions that return specific types using the MetaType, as shown in the examples below.

Example	.NET Type of result
`(Boolean)'true'`	`bool`
`(Date)"2020-01-01"`	`DateTime`
`(DateTime)"2020-01-01 12:00:00"`	`DateTime`
`(Time)"15:14:13"`	`DateTime`
`(TimeSpan)"15:14:13"`	`TimeSpan`
`(TinyInteger)12`	`byte`
`(SmallInteger)12`	`short`
`(Integer)12`	`int`
`(LargeInteger)12`	`long`
`(Currency)12`	`decimal`
`(Double)12`	`double`
`(Guid)'D0A64D79-C2ED-470C-B8AF-4285C96AD415'`	`Guid`
`(Text)12`	`string`

A product can also use any available, fully-qualified .NET type name, as shown in the examples below.

Example	Result
(System.DayOfWeek)5	`DayOfWeek.Friday`
(System.DateTime)"2020-01-01 12:00:00"	`DateTime` object representing "2020-01-01 12:00:00"
(System.TimeSpan)"15:14:13"	`TimeSpan` object representing "15:14:13"

Lists

Use the following operators with lists.

Operator	Beschreibung	Typen	Beispiel	Resultat
`in`	Containment	Any	Array	1 in [1,2,3]

Several of the operators above can be applied to all elements of a list using a list operator. For example, the expression [+::1,1,2,3] evaluates to 1 + 1 + 2 + 3.

The following operators work with lists:

&&
||
#
+
-
*
^

Operator Precedence

Operator precedence is enforced with staggered productions in the grammar and consists of five precedence levels (from most-binding to least):

Level	Operators
1	`^`, `#`, `=>`
2	`*`, `/`, `%`, `&&`
3	`+`, `-`, `
4	`==`, `!=`, `~~`, `!~`, `<`, `>`, `<=`, `>=`, `in`, `%=`, `=%`, `%=%`, `%~`, `~%`, `%~%`, `~@`, `=@`
5	`??`

The following examples show how precedence affects expressions and how to use parentheses to change the precedence.

Example	Result
`1 + 1 * 2`	`3`
`(1 + 1) * 2`	`4`
`6 / 2 * 3`	`9`
`6 / (2 * 3)`	`1`

Identifiers

Any text not contained in quotes and adhering to the following rules is an identifier that refers to data in the context in which the expression is evaluated.

An identifier:

Includes one or more letters (a-z or A-Z), digits (0-9) or underscores
Starts with at least one letter

For the programmers, the following snippets are from the official grammar:

Code Block
ID : LETTER (LETTER\|DIGIT\|'_')*; fragment DIGIT : '0'..'9'; fragment LETTER : ('a'..'z'\|'A'..'Z');

Function calls

The function-call and indexing syntax is also relatively standard.

Type	Example
Function calls	`A(2, "B")` or `A()`
Indexed calls	`A[2, "B"]`

The namespace is always required, except for functions defined in the Global namespace.

For example, Global.EndOfTime() and EndOfTime() are equivalent.

See the list of standard functions and custom functions for more examples.

Chaining

Identifiers can be chained together using dots (".") to reference functions or identifiers in nested namespaces.

For example:

Trim(LastName)
Trim(Company.Address.City)
CreateGuid(Company.Address.City)

Versions Compared

Old Version 1

New Version 2

Key