You do not have permission to edit this page, for the following reasons:

This IP address has been blocked from editing Wikipedia.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

The IP address or range 54.92.0.0/16 has been blocked by ‪Blablubbs‬ for the following reason(s):

The IP address that you are currently using has been blocked because it is believed to be a web host provider or colocation provider. To prevent abuse, web hosts and colocation providers may be blocked from editing Wikipedia.
You will not be able to edit Wikipedia using a web host or colocation provider because it hides your IP address, much like a proxy or VPN.
We recommend that you attempt to use another connection to edit. For example, if you use a proxy or VPN to connect to the internet, turn it off when editing Wikipedia. If you edit using a mobile connection, try using a Wi-Fi connection, and vice versa. If you are using a corporate internet connection, switch to a different Wi-Fi network. If you have a Wikipedia account, please log in.
If you do not have any other way to edit Wikipedia, you will need to request an IP block exemption.

How to appeal if you are confident that your connection does not use a colocation provider's IP address:
If you are confident that you are not using a web host, you may appeal this block by adding the following text on your talk page: ((unblock|reason=Caught by a colocation web host block but this host or IP is not a web host. My IP address is _______. Place any further information here. ~~~~)). You must fill in the blank with your IP address for this block to be investigated. Your IP address can be determined here. Alternatively, if you wish to keep your IP address private you can use the unblock ticket request system. There are several reasons you might be editing using the IP address of a web host or colocation provider (such as if you are using VPN software or a business network); please use this method of appeal only if you think your IP address is in fact not a web host or colocation provider.

Administrators: The IP block exemption user right should only be applied to allow users to edit using web host in exceptional circumstances, and requests should usually be directed to the functionaries team via email. If you intend to give the IPBE user right, a CheckUser needs to take a look at the account. This can be requested most easily at SPI Quick Checkuser Requests. Unblocking an IP or IP range with this template is highly discouraged without at least contacting the blocking administrator.

This block will expire on 10:02, 6 June 2025. Your current IP address is 54.92.174.87.

Even when blocked, you will usually still be able to edit your user talk page, as well as email administrators and other editors.

For information on how to proceed, please read the FAQ for blocked users and the guideline on block appeals. The guide to appealing blocks may also be helpful.

Other useful links: Blocking policy · Help:I have been blocked
This IP address range has been globally blocked.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

This block affects editing on all Wikimedia wikis.
The IP address or range 54.92.0.0/16 has been globally blocked by ‪Jon Kolbert‬ for the following reason(s):

Open proxy/Webhost: See the help page if you are affected

This block will expire on 18:27, 12 November 2028. Your current IP address is 54.92.174.87.

Even while globally blocked, you will usually still be able to edit pages on Meta-Wiki.

If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy. Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

Other useful links: Global blocks · Help:I have been blocked

You can view and copy the source of this page:

((short description|Construct associated with a mathematical operation in computer programs))
((refimprove|date=January 2019))

((About|operators in computer programming|other uses|Operator (disambiguation)))

In [[computer programming]], '''operators''' are constructs defined within [[programming languages]] which behave generally like [[Subroutine|functions]], but which differ [[Syntax (programming languages)|syntactically]] or [[Semantics_(computer science)|semantically]]. 

Common simple examples include arithmetic (e.g. addition with <code>+</code>), comparison (e.g. "[[Greater-than sign|greater than]]" with <code>&gt;</code>), and [[Mathematical logic|logical]] operations (e.g. <code>AND</code>, also written <code>&amp;&amp;</code> in some languages). More involved examples include [[Assignment (computer science)|assignment]] (usually <code>=</code> or <code>:=</code>), [[Field (computer science)|field]] access in a record or [[Object (computer science)|object]] (usually <code>.</code>), and the [[scope resolution operator]] (often <code>::</code> or <code>.</code>). Languages usually define a set of built-in operators, and in some cases allow users to add new meanings to existing operators or even define completely new operators.

==Syntax==
[[Syntax (programming languages)|Syntactically]] operators usually contrast to [[Function (computer science)|functions]]. In most languages, functions may be seen as a special form of prefix operator with fixed [[Order of operations|precedence]] level and associativity, often with compulsory [[Bracket#Parentheses|parentheses]] e.g. <code>Func(a)</code> (or <code>(Func a)</code> in [[Lisp (programming language)|Lisp]]). Most languages support programmer-defined functions, but cannot really claim to support programmer-defined operators, unless they have more than prefix notation and more than a single precedence level. Semantically operators can be seen as special form of function with different calling notation and a limited number of parameters (usually 1 or 2).

The position of the operator with respect to its operands may be [[Polish notation|prefix]], [[infix notation|infix]] or [[postfix notation|postfix]], and the syntax of an [[expression (computer science)|expression]] involving an operator depends on its [[arity]] (number of [[operand]]s), precedence, and (if applicable), [[Operator associativity|associativity]]. Most programming languages support [[binary operation|binary operators]] and a few [[unary operation|unary operators]], with a few supporting more operands, such as the [[?:]] operator in C, which is ternary. There are prefix unary operators, such as unary minus <code>-x</code>, and postfix unary operators, such as [[post-increment]] <code>x++</code>; and binary operations are infix, such as <code>x + y</code> or <code>x = y</code>. Infix operations of higher arity require additional symbols, such as the [[ternary operator]] ?: in C, written as <code>a ? b : c</code> – indeed, since this is the only common example, it is often referred to as ''the'' ternary operator. Prefix and postfix operations can support any desired arity, however, such as <code>1 2 3 4 +</code>.

Occasionally<ref>((Cite web|url=https://reference.wolfram.com/language/tutorial/OperatorInputForms.html.en|title=Operator Input Forms—Wolfram Language Documentation|website=reference.wolfram.com))</ref><ref>((Cite web|url=http://maxima.sourceforge.net/docs/manual/maxima_7.html|title=Maxima 5.42.0 Manual: 7. Operators|website=maxima.sourceforge.net))</ref> parts of a language may be described as "[[matchfix]]" or "[[circumfix]]"<ref>((Cite web|url=https://mythryl.org/my-Prefix__Postfix_and_Circumfix_Operators.html|title=Prefix, Postfix and Circumfix Operators|website=mythryl.org))</ref><ref>((Cite web|url=http://doc.perl6.org/language/operators#___top|title=Operators|website=doc.perl6.org))</ref> operators, either to simplify the language's description or implementation. A circumfix operator consists of two or more parts which enclose its operands. Circumfix operators have the highest precedence, with their contents being evaluated and the resulting value used in the surrounding expression. The most familiar circumfix operator are the parentheses mentioned above, used to indicate which parts of an expression are to be evaluated before others. Another example from physics is the [[Inner product space|inner product]] notation of Dirac's [[bra–ket notation]]. Circumfix operators are especially useful to denote operations that involve many or varying numbers of operands.

The specification of a language will specify the syntax the operators it supports, while languages, such as [[Prolog]] that support programmer-defined operators require that the syntax be defined by the programmer.

==Semantics==
The semantics of operators particularly depends on value, evaluation strategy, and argument passing mode (such as Boolean short-circuiting). Simply, an [[Expression (computer science)|expression]] involving an operator is evaluated in some way, and the resulting [[value (computer science)|value]] may be just a value (an r-value), or may be an object allowing assignment (an l-value).

In simple cases this is identical to usual function calls; for example, addition <code>x + y</code> is generally equivalent to a function call <code>add(x, y)</code> and less-than comparison <code>x &lt; y</code> to <code>lt(x, y)</code>, meaning that the arguments are evaluated in their usual way, then some function is evaluated and the result is returned as a value. However, the semantics can be significantly different. For example, in assignment <code>a = b</code> the target <code>a</code> is not evaluated, but instead its ''location'' (address) is used to store the value of <code>b</code> – corresponding to [[call-by-reference]] semantics. Further, an assignment may be a statement (no value), or may be an expression (value), with the value itself either an r-value (just a value) or an l-value (able to be assigned to). As another example, the [[scope resolution operator]] :: and the element access operator . (as in <code>Foo::Bar</code> or <code>a.b</code>) operate not on values, but on ''names'', essentially [[call-by-name]] semantics, and their value is a name.

Use of l-values as operator operands is particularly notable in unary [[increment and decrement operators]]. In C, for instance, the following statement is legal and well-defined, and depends on the fact that array indexing returns an l-value:
<syntaxhighlight lang=c>
x = ++a[i];
</syntaxhighlight>

An important use is when a left-associative binary operator modifies its left argument (or produces a [[side effect (computer science)|side effect]]) and then evaluates to that argument as an l-value.((efn|Conversely a right-associative operator with its right argument, though this is rarer.)) This allows a sequence of operators all affecting the original argument, allowing a [[fluent interface]], similar to [[method cascading]]. A common example is the <code>&lt;&lt;</code> operator in the C++ <code>[[iostream]]</code> library, which allows fluent output, as follows:
<syntaxhighlight lang=cpp>
cout << "Hello" << " " << "world!" << endl;
</syntaxhighlight>

==User-defined operators==
A language may contain a fixed number of built-in operators (e.g. ((mono|1=+, -, *, &lt;, &lt;=, !, =)), etc. in [[Operators in C and C++|C and C++]], [[PHP]]), or it may allow the creation of programmer-defined operators (e.g. [[Prolog]],<ref>((Cite web|url=https://www.swi-prolog.org/pldoc/man?predicate=op/3|title=SWI-Prolog -- op/3|website=www.swi-prolog.org))</ref> [[Seed7]],<ref>((Cite web|url=http://seed7.sourceforge.net/examples/operator.htm|title=Declare an operator|website=seed7.sourceforge.net))</ref> [[F Sharp (programming language)|F#]], [[OCaml]], [[Haskell programming language|Haskell]]). Some programming languages restrict operator symbols to special characters like ((mono|1='''[[Addition|+]]''')) or ((mono|1='''[[Assignment (computer science)|:=]]''')) while others allow also names like <code>[[Integer_division#Division_of_integers|'''div''']]</code> (e.g. [[Pascal (programming language)|Pascal]]).

Most languages have a built-in set of operators, but do not allow user-defined operators, as this significantly complicates parsing.((efn|Introducing a new operator changes the [[lexical specification]] of the language, which changes the [[lexical analysis]]. The arity and precedence of the operator is then part of the phrase syntax of the language, which changes the phrase-level analysis. For example, adding an operator <code>@</code> requires lexing and tokenizing this character, and the phrase structure (syntax tree) depends on the arity and precedence of this operator.)) Many languages only allow operators to be used for built-in types, but others allow existing operators to be used for user-defined types; this is known as [[operator overloading]]. Some languages allow new operators to be defined, however, either at compile time or at run time. This may involve meta-programming (specifying the operators in a separate language), or within the language itself. Definition of new operators, particularly runtime definition, often makes correct [[static analysis]] of programs impossible, since the syntax of the language may be Turing-complete, so even constructing the syntax tree may require solving the halting problem, which is impossible. This occurs for [[Perl]], for example, and some dialects of [[Lisp (programming language)|Lisp]].

==Examples==
((category see also|Operators (programming)))
Common examples that differ syntactically are mathematical [[arithmetic operation]]s, e.g. "&gt;" for "[[inequality (mathematics)|greater than]]", with names often outside the language's set of [[identifier (computer science)|identifiers]] for functions, and called with a syntax different from the language's syntax for calling functions. As a function, "greater than" would generally be named by an identifier, such as <code>gt</code> or <code>greater_than</code> and called as a function, as <code>gt(x, y)</code>. Instead, the operation uses the special character <code>&gt;</code> (which is tokenized separately during [[lexical analysis]]), and infix notation, as <code>x &gt; y</code>.

Common examples that differ semantically (by argument passing mode) are Boolean operations, which frequently feature [[short-circuit evaluation]]: e.g. a short-circuiting conjunction (X AND Y) that only evaluates later arguments if earlier ones are not false, in a language with strict call-by-value functions. This behaves instead similarly to if/then/else.

Less common operators include:
* [[Comma operator]]: <code>e, f</code>
* [[Dereference operator]]: <code>*p</code> and address-of operator: <code>&amp;x</code>
* [[?:]] or ternary operator: <code>number = spell_out_numbers ? "forty-two" : 42</code>
** [[Elvis operator]]: <code>x ?: y</code>
* [[Null coalescing operator]]: <code>x ?? y</code>
* [[Spaceship operator]] (for [[three-way comparison]]): <code>x &lt;=&gt; y</code>
* ((anchor|Compound operator|Fused operation)) [[Compound operator]]s<!-- This should probably become a separate article at a later stage --> combining two or more [[atomic operation]]s into one to simplify [[compound expression|expression]]s, ease compiler optimizations depending on the underlying hardware implementation, or improve performance for speed or size. An example are the set of [[compound assignment operator]]s (aka augmented assignments) in C/C++: <code>+=</code>, <code>-=</code>, <code>*=</code>, <code>/=</code>, <code>%=</code>, <code><<=</code>, <code>>>=</code>, <code>&=</code>, <code>^=</code>, <code>|=</code> Similarly, some [[digital signal processor]]s provide special [[opcode]]s for [[fused operation]]s<!-- This should probably become a separate article at a later stage, possibly combined with the similar topic on compound operations --> like [[multiply-accumulate]] (MAC/MAD) or [[fused multiply-add]] (FMA) and some high-performance software libraries support functions like [[cis (mathematics)|((math|1=cis ''x'' = cos ''x'' + ''i'' sin ''x''))]] to boost processing speed or reduce code size.

==Compilation==
A compiler can implement operators and functions with [[Subroutine|subroutine calls]] or with [[Inline expansion|inline code]]. Some built-in operators supported by a language have a direct mapping to a small number of [[Machine code|instructions]] commonly found on [[central processing units]], though others (''e.g.'' '+' used to express [[string concatenation]]) may have complicated implementations.

== Operator overloading ==
((main|Operator overloading))

In some programming languages an operator may be ''ad hoc polymorphic'', that is, have definitions for more than one kind of data, (such as in [[Java (programming language)|Java]] where the ((code|+)) operator is used both for the addition of numbers and for the concatenation of strings). Such an operator is said to be ''overloaded''. In languages that support operator overloading by the programmer (such as [[C++]]) but have a limited set of operators, operator overloading is often used to define customized uses for operators.

In the example ((code|IF ORDER_DATE > "12/31/2011" AND ORDER_DATE < "01/01/2013" THEN CONTINUE ELSE STOP|basic)), the operators are: ((code|>)) (greater than), ((code|AND)) and ((code|<)) (less than).

== Operand coercion ==
((further|Type conversion))
Some languages also allow for the operands of an operator to be implicitly converted, or ''[[Type conversion#Implicit type conversion|coerced]]'', to suitable data types for the operation to occur. For example, in [[Perl]] coercion rules lead into <code>12 + "3.14"</code> producing the result of <code>15.14</code>. The text <code>"3.14"</code> is converted to the number 3.14 before addition can take place. Further, <code>12</code> is an integer and <code>3.14</code> is either a floating or fixed-point number (a number that has a decimal place in it) so the integer is then converted to a floating point or fixed-point number respectively.

[[JavaScript]] follows opposite rules—finding the same expression above, it will convert the integer <code>12</code> into a string <code>"12"</code>, then concatenate the two operands to form <code>"123.14"</code>.

In the presence of coercions in a language, the programmer must be aware of the specific rules regarding operand types and the operation result type to avoid subtle programming mistakes.

== Operator features in programming languages ==
The following table shows the operator features in several programming languages:

{| class="sortable wikitable"
|-
!Programming language
!Nonalphanumeric operator symbols
!Alphanumeric operator symbols
!Prefix
!Infix
!Postfix
!Precedence
!Associativity
! ((verth|Overloading))
! ((verth|Programmer-defined<br/>overloading))
! ((verth|Programmer-defined<br/>operator symbols))
|-
| [[ALGOL 68]]
| ((mono|1=+* ** * / % %* %× - + &lt; &lt;= >= > = /= & -:= +:= *:= /:= %:= %*:= +=: :=: :/=:))
(All operators have '''bold''' Alphanumeric equivalents, c.f. next column.  Some have non [[ASCII]] equivalents, c.f. below.)
((mono|1=¬ +× ⊥ ↑ ↓ ⌊ ⌈ × ÷ ÷× ÷* □ ≤ ≥ ≠ ∧ ∨ ×:= ÷:= ÷×:= ÷*:= %×:= :≠:))
| ((mono|'''not''' '''abs''' '''arg''' '''bin''' '''entier''' '''leng''' '''level''' '''odd''' '''repr''' '''round''' '''shorten''' '''i''' '''shl''' '''shr''' '''up''' '''down''' '''lwb''' '''upb''' '''lt''' '''le''' '''ge''' '''gt''' '''eq''' '''ne''' '''and''' '''or''' '''over''' '''mod''' '''elem''' '''minusab''' '''plusab''' '''timesab''' '''divab''' '''overab''' '''modab''' '''plusto''' '''is''' '''((Not a typo|isnt))'''))
| ((Yes))
| ((Yes))
| ((No))
| ((Yes)) <small>(prefix operators always have priority 10)</small>
| Infix operators are left associative, prefix operators are right associative
| ((Yes))
| ((Yes))
| ((Yes))
|-
| [[APL (programming language)|APL]]
| ((mono|1=+ - × ÷ ⌈ ⌊ * ⍟ <nowiki>|</nowiki> ! ○ ~ ∨ ∧ ⍱ ⍲ &lt; ≤ = ≥ > ≠ . @ ≡ ≢ ⍴ , ⍪ ⍳ ↑ ↓ ? ⍒ ⍋ ⍉ ⌽ ⊖ ∊ ⊥ ⊤ ⍎ ⍕ ⌹ ⊂ ⊃ ∪ ∩ ⍷ ⌷ ∘ → ← / ⌿ \ ⍀ ¨ ⍣ & ⍨ ⌶ ⊆ ⊣ ⊢ ⍠ ⍤ ⌸ ⌺ ⍸))
| bgcolor="yellow" | Alphanumeric symbols need a ⎕ before the keyword
| ((Yes)) <small>(first-order functions only)</small>
| ((Yes)) 
| ((Yes)) <small>(higher-order functions only)</small>
| Higher-order functions precede first-order functions
| Higher-order functions are left associative, first-order functions are right associative
| ((Yes))
| ((Yes))
| ((Yes)) <small>(alphanumeric only)</small>
|-
| [[C (programming language)|C]]
| rowspan="2" | ((mono|1=() [] -> . ! ~ ++ -- + - * & / % << >> < <= > >= == != ^ <nowiki>|</nowiki> && <nowiki>||</nowiki> [[?:]] = += -= *= /= %= &= ^= |= <<= >>=))
| ((mono|1=[[sizeof]]))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((No))
| ((No))
|-
| [[C++]] ([[Operators in C and C++|more]])
| ((mono|1=[[sizeof]] [[typeid]] [[new (C++)|new]] [[delete (C++)|delete]] [[Exception handling|throw]] [[decltype]] [[static_cast]] [[dynamic cast]] [[reinterpret_cast]] [[const_cast]]))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((No))
|-
| [[C sharp (programming language)|C#]] ([[C Sharp syntax#Operators|more]])
| Same as C/C++, along with ((mono|[[?.]] ?[] [[Null coalescing operator|??]] <nowiki>??=</nowiki>))
| ((mono|1=[[sizeof]] nameof new stackalloc await [[Exception handling|throw]] checked unchecked is as delegate default true false)) <br /> '''[[Language Integrated Query|LINQ]]:''' ((mono|1=from select where group...by group...by...into join...in...on...equals join...in...on...equals...into orderby orderby...descending)) <br /> '''[[Roslyn (compiler)|Roslyn]]-only:''' ((mono|1=__makeref __refvalue __reftype))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((No))
|-
| [[Java (programming language)|Java]]
| Same as C/C++
| [[Java syntax#Instantiation|new]] [[Exception handling|throw]] [[instanceof]]
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((No))
| ((No))
|-
| [[Eiffel (programming language)|Eiffel]]
| ((mono|1=[] + - * / // = /= ))
| ((mono|1=not and or implies "and then" "or else" ))
| ((Yes))
| ((Yes))
| ((No))
| ((Yes))
| ((Yes))
| ((No))
| ((Yes))
| ((Yes))
|-
| [[Haskell (programming language)|Haskell]]
| ((mono|1=+ - * / ^ ^^ ** == /= > < >= <= && <nowiki>||</nowiki> >>= >> $ $! . ++ !! :)) <small>Many more in common libraries</small>
| bgcolor="yellow" | The function's name must be put into backticks
| ((Yes))
| ((Yes))
| ((No))
| ((Yes))
| ((Yes))
| colspan="2" ((Yes)), using [[Type class]]es
| ((Yes))
|-
| [[Pascal (programming language)|Pascal]]
| ((mono|1=* / + - = < > <> <= >= :=))
| [[Negation#Programming|not]] [[Integer division#Division of integers|div]] [[Modulo operation|mod]] [[Logical conjunction|and]] [[Logical disjunction|or]] in
| ((Yes))
| ((Yes))
| ((No))
| ((Yes))
| ((Yes))
| ((Yes))
| ((No))
| ((No))
|-
| [[Perl]]
| ((mono|1=-> ++ -- ** ! ~ \ + - . =~ !~ * / % < > <= >= == != <=> ~~ & <nowiki>|</nowiki> ^ &amp;&amp; <nowiki>||</nowiki> ' ''((Not a typo|  // .. ... ?: = += -= *= , =>)) ))
| ((mono|1=print sort chmod chdir rand and or not xor lt gt le ge eq ne cmp x ))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((No))
|-
| [[PHP]]
| ((mono|1=[] ** ++ -- ~  @!<ref>((Cite web|url=https://php.net/manual/en/language.operators.errorcontrol.php|title=PHP: Error Control Operators - Manual|website=php.net))</ref> * / % + - . << >> < <= > >= == != === !== <> [[Spaceship operator|<=>]] & ^ <nowiki>|</nowiki> && <nowiki>||</nowiki> [[Null coalescing operator|??]] [[?:]] = += -= *= **= /= .= %= &= <nowiki>|=</nowiki> ^= <<= >>= ))
| ((mono|1=clone new unset print echo isset [[instanceof]] [[Logical conjunction|and]] [[Logical disjunction|or]] [[Exclusive or|xor]]))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((No))
| ((No))
| ((No))
|-
| [[PL/I]]
| ((mono|1=( ) -> + - * / ** > ¬> >= = ¬= <= < ¬< ¬ <nowiki>&</nowiki> <nowiki>|</nowiki> <nowiki>||</nowiki>))
|  
| ((Yes))
| ((Yes))
| ((No))
| ((Yes))
| ((Yes))
| ((No))
| ((No))
| ((No))
|-
| [[Prolog]]
| ((mono|1=:- ?- ; , . =.. = \= < =< >= > == \== - + / *))
| ((mono|1=spy nospy not is mod))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((No))
| ((No))
| ((Yes))
|-
| [[Raku (programming language)|Raku]]
| ((mono|1=++ -- ** ! ~ ~~ * / + - . < > <= >= == != <=> & <nowiki>|</nowiki> ^ &amp;&amp; <nowiki>||</nowiki> //)) <ref>((Cite web|url=https://docs.perl6.org/language/operators|title=Operators|website=docs.perl6.org))</ref>
| ((mono|1=print sort chmod chdir rand and or not xor lt gt le ge eq ne leg cmp x xx))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))<ref>((Cite web|url=https://docs.perl6.org/language/functions#Defining_Operators|title=Functions|website=docs.perl6.org))</ref>
|-
| [[Seed7]]
| ((mono|1={} [] -> ** ! + - * / << >> & >< <nowiki>|</nowiki> = <> > >= < <= <& := +:= -:= *:= /:= <<:= >>:= &:= @:=))
| ((mono|1=conv varConv parse [[Complex conjugate|conj]] [[Integer division#Division of integers|div]] [[Remainder|rem]] [[Modulo operation|mdiv mod]] times mult in [[Negation#Programming|not]] [[Logical conjunction|and]] [[Logical disjunction|or]] digits lpad rpad lpad0))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
|-
| [[Smalltalk]]
| (yes - Up to two characters<ref name="BinaryMessages">((cite web|first=Adele|last=Goldberg|url=http://stephane.ducasse.free.fr/FreeBooks/BlueBook/Bluebook.pdf|title=Smalltalk-80: The Language and its Implementation, p. 27, ISBN 0-201-11371-6))</ref>)
| bgcolor="yellow" | Alphanumeric symbols need a colon after the keyword
| ((No))
| ((Yes))
| ((Yes))
| ((No))
| ((No))
| ((Yes))
| ((Yes))
| ((Yes))
|-
| [[Swift (programming language)|Swift]]
| Any Unicode symbol string except ((mono|1=.)), including ((mono|1=! ~ + - * / % =+ =- =* =/ =% &+ &- &* =&+ =&- =&* && <nowiki>||</nowiki> << >> & <nowiki>|</nowiki> ^ == != < <= > >= ?? ... ..<)) in standard library
| ((mono|1=is as as?))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes)) <small>(defined as partial order in precedence groups)</small>
| ((Yes)) <small>(defined as part of precedence groups)</small>
| ((Yes))
| ((Yes))
| ((Yes))
|-
| [[Visual Basic .NET]]
| rowspan="2" | ((mono|1=() . ! ?() ?. ?! + - * / \ & << >> < <= > >= ^ <> = += -= *= /= \= &= ^= <<= >>=))
| ((mono|1=New Await Mod Like Is IsNot Not And AndAlso Or OrElse Xor If(...,...) If(...,...,...) GetXmlNamespace(...) GetType(...) NameOf(...) TypeOf...Is TypeOf...IsNot DirectCast(...,...) TryCast(...,...) CType(...,...) CBool(...) CByte(...) CChar(...) CDate(...) CDec(...) CDbl(...) CInt(...) CLng(...) CObj(...) CSByte(...) CShort(...) CSng(...) CStr(...) CUInt(...) CULng(...) CUShort(...))) <br /> '''[[Language Integrated Query|LINQ]]:''' ((mono|1=From Aggregate...Into Select Distinct Where ((nowrap|<Order By>...[Ascending<nowiki>|</nowiki>Descending])) Take ((nowrap|<Take While>)) Skip ((nowrap|<Skip While>)) Let Group...By...Into Join...On <Group Join...On...Into>))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((Yes))
| ((No))
|-
|}

==See also==
*[[Relational operator]]

==Notes==
((notelist))

==References==
((reflist))

[[Category:Operators (programming)| ]]
[[Category:Programming constructs]]

Pages transcluded onto the current version of this page (help):

Operator (computer programming) (edit)
Template:About (view source) (template editor protected)
Template:Ambox (view source) (template editor protected)
Template:Anchor (view source) (template editor protected)
Template:Category see also (view source) (template editor protected)
Template:Category see also/Category pair check (view source) (template editor protected)
Template:Cite web (view source) (protected)
Template:Code (view source) (template editor protected)
Template:Efn (view source) (template editor protected)
Template:Find sources mainspace (view source) (template editor protected)
Template:Further (view source) (template editor protected)
Template:Ifsubst (view source) (template editor protected)
Template:Main (view source) (template editor protected)
Template:Main other (view source) (protected)
Template:Math (view source) (template editor protected)
Template:Mono (view source) (template editor protected)
Template:Mono/styles.css (view source) (template editor protected)
Template:More citations needed (view source) (template editor protected)
Template:No (view source) (template editor protected)
Template:Not a typo (view source) (template editor protected)
Template:Notelist (view source) (template editor protected)
Template:Nowrap (view source) (protected)
Template:Pagetype (view source) (protected)
Template:Refimprove (view source) (template editor protected)
Template:Reflist (view source) (protected)
Template:Reflist/styles.css (view source) (protected)
Template:SDcat (view source) (protected)
Template:Short description (view source) (protected)
Template:Short description/lowercasecheck (view source) (protected)
Template:Sic (view source) (template editor protected)
Template:Verth (edit)
Template:Vertical header (view source) (semi-protected)
Template:Yes (view source) (template editor protected)
Module:About (view source) (template editor protected)
Module:Anchor (view source) (template editor protected)
Module:Arguments (view source) (protected)
Module:Category handler (view source) (protected)
Module:Category handler/blacklist (view source) (protected)
Module:Category handler/config (view source) (protected)
Module:Category handler/data (view source) (protected)
Module:Category handler/shared (view source) (protected)
Module:Category see also (view source) (template editor protected)
Module:Check for unknown parameters (view source) (protected)
Module:Citation/CS1 (view source) (protected)
Module:Citation/CS1/COinS (view source) (protected)
Module:Citation/CS1/Configuration (view source) (protected)
Module:Citation/CS1/Date validation (view source) (protected)
Module:Citation/CS1/Identifiers (view source) (protected)
Module:Citation/CS1/Utilities (view source) (protected)
Module:Citation/CS1/Whitelist (view source) (protected)
Module:Citation/CS1/styles.css (view source) (protected)
Module:Disambiguation/templates (view source) (protected)
Module:Find sources (view source) (template editor protected)
Module:Find sources/config (view source) (template editor protected)
Module:Find sources/links (view source) (template editor protected)
Module:Find sources/templates/Find sources mainspace (view source) (template editor protected)
Module:Format link (view source) (template editor protected)
Module:Hatnote (view source) (template editor protected)
Module:Hatnote/styles.css (view source) (template editor protected)
Module:Hatnote list (view source) (template editor protected)
Module:Labelled list hatnote (view source) (template editor protected)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:Namespace detect/config (view source) (protected)
Module:Namespace detect/data (view source) (protected)
Module:Pagetype (view source) (protected)
Module:Pagetype/config (view source) (protected)
Module:Pagetype/disambiguation (view source) (protected)
Module:Pagetype/rfd (view source) (template editor protected)
Module:Pagetype/setindex (view source) (protected)
Module:Pagetype/softredirect (view source) (protected)
Module:SDcat (view source) (protected)
Module:String (view source) (protected)
Module:TableTools (view source) (protected)
Module:Unsubst (view source) (protected)
Module:Vertical header (view source) (semi-protected)
Module:Vertical header/styles.css (view source) (semi-protected)
Module:Wikitext Parsing (view source) (protected)
Module:Yesno (view source) (protected)

Return to Operator (computer programming).

Retrieved from "https://en.wikipedia.org/wiki/Operator_(computer_programming)"