演算子言語比較 - ntuf/Tips GitHub Wiki

JavaScript|C#(.NET) |SQL(Oracle) |PL/SQL(Oracle) | Lisp ---------------------------------- | ----------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- 四則演算 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | 値 + 値 | (+ 値 値 …)
値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | 値 - 値 | (- 値 値 …)
値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | 値 * 値 | (* 値 値 …)
値 / 値 | 値 / 値 | 値 / 値 | 値 / 値 | 値 div 値 | 値 / 値 | 値 / 値 | 値 / 値 | 値 / 値 | 値 / 値 | `値 / 値

	値 div 値`                                                                          | `値 / 値`                                                                                         | `値 / 値`                                                                                                            | `値 / 値`                                                                                           | `値 / 値`                                                                                                                                                                         | `(/ 値 値 …)`                                                                                            

値 \ 値 | 値 \ 値 | 値 \ 値 | 値 \ 値 | | | | | | | | | | | |
値 MOD 値 | 値 Mod 値 | 値 Mod 値 | 値 Mod 値 | 値 mod 値 | | 値 % 値 | 値 % 値 | 値 % 値 | 値 % 値 | `値 % 値

	値 mod 値`                                                                          | `値 % 値`                                                                                         |                                                                                                                    | `MOD(値,値)`                                                                                        | `MOD(値,値)`                                                                                                                                                                      | `(mod 値 値)  

	(rem 値 値)`                                                                             

比較演算 | =,<> | =,<> | =,<> | =,<> | =,<> | =,^= | `==,!=…数値

	eq,ne<span class="cmt">…文字列</span>`                | `==,!=`                                                                                   | `==,!=`                                                                                         | `値.equals(値)`                                                                                 | `==,!=  

	eq,ne`                                                                              | `==,!=<span class="cmt">…片方が数値なら数値に変換して比較(変換できないなら不一致扱い)</span>  

	===,!==<span class="cmt">…型の変換を伴わない比較</span>` | `==,!=`                                                                                           | `=, <>,!=,^=  

	IS NULL,IS NOT NULL`                                                                                                                                          | `=, <>,!=,^=  

	IS NULL,IS NOT NULL`                                                                  | `eq`                                                                                         

Is | Is | `Is

	IsNot` <span class="cmt">…VB2005</span>                                          | `==,!=`                                                                                   | `Object.ReferenceEquals(objA, objB)`                                                                            | `eql,equal  

	=,/=<span class="cmt">…数値  

	3つ以上の引数を持つ場合、「全て等しい」「全て等しくない」</span>`        
                               | `Like`                                                                                          |                                                                                           | `Like`                                                                                    |                                                                                                                 |                                                                                              | `=~,!~`                                                                                    |                                                                                            |                                                                                           |                                                                                                 |                                                                                               |                                                                                                 |                                                                                                                    | `LIKE`                                                                                            | `LIKE`                                                                                                                                                                          |                                                                                                        

<,>,<=,>= | <,>,<=,>= | <,>,<=,>= | <,>,<=,>= | <,>,<=,>= | <,>,<=,>=,^<,^> | `<,>,<=,>=…数値

	</span>lt,gt,le,ge<span class="cmt">…文字列</span>`      | `<,>,<=,>=`                                                                                | `<,>,<=,>=`                                                                               | `<,>,<=,>=`                                                                                     | `<,>,<=,>=  

	lt,gt,le,ge`                                                                  | `<,>,<=,>=`                                                                                     |                                                                                                                    | `<,>,<=,>=,BETWEEN`                                                                               | `<,>,<=,>=,BETWEEN`                                                                                                                                                             | `<,>,<=,>=  

	<span class="cmt">3つ以上の引数を持つ場合、単調増加・単調減少</span>`                                       

論理演算 | AND,OR
ビットの論理演算 | And,Or | And,Or | `AndAlso,OrElse

	`
	<span class="cmt">左が条件を決定したら、右は計算しない</span>                                            | `and,or`  

比較演算より優先度が高い | &,| | and,or
左が条件を決定したら、右は計算しない | &&,||
左が条件を決定したら、右は計算しない | &&,||
左が条件を決定したら、右は計算しない | &&,||
左が条件を決定したら、右は計算しない | `&&,||

	and,or`                                                                             | `&&,||`  

左が条件を決定したら、右は計算しない | | AND,OR | AND,OR | `(and 値 値 …)

	(or 値 値 …)`  

左が条件を決定したら、右は計算しない
否定 | NOT 値 | Not 値 | Not 値 | Not 値 | not 値 | ^値 | not 値 | !値 | !値 | !値 | `!値

	not 値`                                                                                 | `!値`                                                                                                               |                                                                                                   | `NOT 値`                                                                                                                                                                         | `NOT 値`                                                                                                 | `(not 値)`                                                                                    

ビット演算 | なし | | | | なし | | 値 << 数 | 値 << 数 | 値 << 数 | 値 << 数 | | 値 << 数 | | | | (ash 値 正数)
なし | | | | なし | | 値 >> 数 | 値 >> 数 | 値 >> 数 | 値 >> 数 | | 値 >> 数 | | | | (ash 値 負数)
なし | | | | なし | | | なしunsignedにして>>) | なしunsignedにして>>) | 値 [>>>](http://www.ne.jp/asahi/hishidama/home/tech/java/expression.html) 数 | | 値 >>> 数 | | | |
値 AND 値 | 値 And 値 | 値 And 値 | 値 And 値 | なし | | 値 & 値 | 値 & 値 | 値 & 値 | 値 & 値 | | 値 & 値 | | | | (logand 値 値)
値 OR 値 | 値 Or 値 | 値 Or 値 | 値 Or 値 | なし | | 値 | 値 | 値 | 値 | 値 | 値 | 値 | 値 | | 値 | 値 | | | | (logor 値 値)
値 XOR 値 | 値 Xor 値 | 値 Xor 値 | 値 Xor 値 | なし | | 値 ^ 値 | 値 ^ 値 | 値 ^ 値 | 値 ^ 値 | | 値 ^ 値 | | | | (logxor 値 値)
NOT 値 | Not 値 | Not 値 | Not 値 | なし | | ~値 | ~値 | ~値 | ~値 | | ~値 | | | | (lognot 値)
インクリメント・デクリメント | なし | なし | | | なし | | ++$変数 | ++変数 | ++変数 | ++変数 | | ++変数 | | | | (1+ 値)
なし | なし | | | なし | | --$変数 | --変数 | --変数 | --変数 | | --変数 | | | | (1- 値)
なし | なし | | 変数 += 値 | なし | | $変数 += 値; | 変数 += 値 | 変数 += 値 | 変数 += 値 | | 変数 += 値 | | | | (incf 変数 値)
なし | なし | | 変数 -= 値 | なし | | $変数 -= 値; | 変数 -= 値 | 変数 -= 値 | 変数 -= 値 | | 変数 -= 値 | | | | (decf 変数 値)
べき乗 | 値 ^ 指数 | 値 ^ 指数 | 値 ^ 指数 | 値 ^ 指数 | | 値 ** 指数 | 値 ** 指数 | pow(値, 指数) | pow(値, 指数) | Math.pow(値, 指数) | | Math.pow(値, 指数) | | POWER(値, 指数) | POWER(値, 指数) | (expt 値 指数)
代入演算子 | = | = | = | `=

	+= -= *= /=  

	\=  

	^=`                                                                            | `:=`                                                                                         | `=`                                                                                        | `=  

	+= -= *= /= %=  

	&= |= ^=  

	<<= >>=  

	&&= ||=  

	**=`                   | `=  

	+= -= *= /= %=  

	&= |= ^=  

	<<= >>=`                                        | `=  

	+= -= *= /= %=  

	&= |= ^=  

	<<= >>=`                                              | `=  

	+= -= *= /= %=  

	&= |= ^=  

	<<= >>= >>>=`                                       |                                                                                                 | `=  

	+= -= *= /= %=  

	&= |= ^=  

	<<= >>= >>>=`                                                            | `=  

	+= -= *= /= %=  

	&= |= ^=  

	<<= >>=`                                                |                                                                                                                                                                                 | `:=`                                                                                                    |                                                                                              
                               | <label for="id4L1">MSX-BASIC</label>                                                            | <label for="id4L2">VBA</label>                                                            | <label for="id4L3">VBS</label>                                                            | <label for="id4L4">VB.NET</label>                                                                               | <label for="id4L5">PASCAL</label>                                                            | <label for="id4L6">PL/I</label>                                                            | <label for="id4L7">Perl</label>                                                            | <label for="id4L8">C言語</label>                                                            | <label for="id4L9">VC++(MFC)</label>                                                            | <label for="id4L10">Java</label>                                                              | <label for="id4L11">JSP EL</label>                                                              | <label for="id4L12">JavaScript</label>                                                                             | <label for="id4L13">C#(.NET)</label>                                                              | <label for="id4L14">SQL(<a href="http://www.ne.jp/asahi/hishidama/home/tech/index.html#ORACLE">Oracle</a>)</label>                                                              | <label for="id4L15">PL/SQL(Oracle)</label>                                                              | <label for="id4L16">Lisp</label>                                                             

四捨五入 | なし | `Round(値)

	Round(値,小数以下の桁)`                                                           | `Round(値,小数以下の桁)`                                                                         | `Math.Round(値)  

	Round(値,小数以下の桁)`                                                                            | `round(値)`                                                                                   |                                                                                            |                                                                                            |                                                                                           |                                                                                                 | `Math.round(値)`                                                                               |                                                                                                 | `Math.round(値)`                                                                                                    |                                                                                                   | `ROUND(値)  

	ROUND(値,小数以下の桁)`                                                                                                                                                 | `ROUND(値)  

	ROUND(値,小数以下の桁)`                                                                         | `(round 値)`                                                                                  

整数化 | INT(値) | Int(値) | Int(値) | Math.Floor(値) | | | | | | Math.floor(値) | | Math.floor(値) | | FLOOR(値) | FLOOR(値) | (floor 値)
-INT(-値) | -Int(-値) | -Int(-値) | Math.Ceiling(値) | | | | | | Math.ceil(値) | | Math.ceil(値) | | CEIL(値) | CEIL(値) | (ceiling 値)
切り上げ | | | RoundUp(値,桁) | | | | | | | | | | | | |
切り捨て | FIX(値) | Fix(値) | `Fix(値)

	RoundDown(値,桁)`                                                              | `Fix(値)`                                                                                                        | `trunc(値)`                                                                                   |                                                                                            |                                                                                            |                                                                                           |                                                                                                 |                                                                                               |                                                                                                 |                                                                                                                    |                                                                                                   | `TRUNC(値)`                                                                                                                                                                      | `TRUNC(値)`                                                                                              | `(truncate 値)`                                                                               

絶対値 | ABS(値) | Abs(値) | Abs(値) | Math.Abs(値) | abs(値) | | | | | Math.abs(値) | | Math.abs(値) | | ABS(値) | ABS(値) | (abs 値)
符号 | SGN(値) | Sgn(値) | Sgn(値) | Math.Sign(値) | | | 値 <=> 0 | | | `Math.signum(値)

	Integer.signum(値)  

	`<span class="cmt">…JDK1.5以降</span>               |                                                                                                 |                                                                                                                    |                                                                                                   | `SIGN(値)`                                                                                                                                                                       | `SIGN(値)`                                                                                               | `(signum 値)  

	(zerop 値)  

	(plusp 値)  

	(minusp 値)`                                   

平方 | 値^2 | 値 ^ 2 | 値 ^ 2 | `値 ^ 2

	Math.Pow(値,2)`                                                                                      | `sqr(値)`                                                                                     | `値 ** 2`                                                                                   | `値 ** 2`                                                                                   | `pow(値,2)`                                                                                | `pow(値,2)`                                                                                      | `Math.pow(値,2)`                                                                               |                                                                                                 | `Math.pow(値,2)`                                                                                                    |                                                                                                   | `POWER(値,2)`                                                                                                                                                                    | `POWER(値,2)`                                                                                            | `(expt 値 2)`                                                                                 

平方根 | SQR(値) | Sqr(値) | Sqr(値) | Math.Sqrt(値) | sqrt(値) | | | | | Math.sqrt(値) | | Math.sqrt(値) | | | | `(sqrt 値)

	(isqrt 値)`                                                                    

三角関数 | `SIN(値)

	COS(値)  

	TAN(値)`                                                                | `Sin(値)  

	Cos(値)  

	Tan(値)`                                                          | `Sin(値)  

	Cos(値)  

	Tan(値)`                                                          | `Math.Sin(値)  

	Math.Cos(値)  

	Math.Tan(値)`                                                                 | `sin(値)  

	cos(値)`                                                                         |                                                                                            |                                                                                            |                                                                                           |                                                                                                 | `Math.sin(値)  

	Math.cos(値)  

	Math.tan(値)`                                               |                                                                                                 | `Math.sin(値)  

	Math.cos(値)  

	Math.tan(値)`                                                                    |                                                                                                   |                                                                                                                                                                                 |                                                                                                         | `(sin 値)  

	(cos 値)  

	(tan 値)`                                                          

円周率 | なし | WorksheetFunction.Pi | | | | | | | | Math.PI | | | | | |
対数 | | | | | | | | | | | | | | | | (log 値 基数)
自然対数 | LOG(値) | Log(値) | Log(値) | Math.Log(値) | ln(値) | | | | | Math.log(値) | | Math.log(値) | | | | (log 値)
指数関数eのべき乗 | EXP(値) | Exp(値) | Exp(値) | Math.Exp(値) | exp(値) | | | | | Math.exp(値) | | Math.exp(値) | | | | (exp 値)
奇数判断 | なし | | | | odd(値) | | | | | | | | | | | `(oddp 値)

	<span class="cmt">(evenp 値)</span>`                                           

乱数の種 | RND(負の値) | `Rnd(負の値)

	Randomize`                                                                 | `Randomize()`                                                                             | `Rnd(負の値)  

	Randomize`                                                                                       |                                                                                              |                                                                                            |                                                                                            |                                                                                           |                                                                                                 | `Random#setSeed(値)`                                                                           |                                                                                                 |                                                                                                                    |                                                                                                   |                                                                                                                                                                                 |                                                                                                         | `(make-random-state 種)`                                                                      

乱数生成 | RND(正の値) | Rnd(正の値) | Rnd() | Rnd(正の値) | | | | | | `Random#nextDouble()

	Math#random()`                                                      |                                                                                                 | `Math.random()`                                                                                                    |                                                                                                   |                                                                                                                                                                                 |                                                                                                         | `(random 値)`                                                                                 

0〜1 | 0〜1 | 0〜1 | 0〜1 | 0〜1 | | 0〜1 | 0〜値
if | 条件*(偽-真)+偽 | IIf(条件,真,偽) | | `IIf(条件,真,偽)

	[If](http://msdn.microsoft.com/ja-jp/library/bb513985.aspx)(条件,真,偽)` |                                                                                              |                                                                                            | `条件 ? 真 : 偽`                                                                               | `条件 ? 真 : 偽`                                                                              | `条件 ? 真 : 偽`                                                                                    | `条件 ? 真 : 偽`                                                                                  | `条件 ? 真 : 偽`                                                                                    | `条件 ? 真 : 偽`                                                                                                       |                                                                                                   | `CASE WHEN 条件 THEN 値 〔WHEN 条件 THEN 値〕… 〔ELSE 値〕 
	END`                                                                                                                         | `CASE WHEN 条件 THEN 値 〔WHEN 条件 THEN 値〕… 〔ELSE 値〕 
	END CASE`                                            | `(if 条件 真 偽)`                                                                                

選択 | | `Switch(

 項目 = 値, 変換値,

 項目 = 値, 変換値,

 True, その他変換値

	)`        |                                                                                           |                                                                                                                 |                                                                                              |                                                                                            |                                                                                            |                                                                                           |                                                                                                 |                                                                                               |                                                                                                 |                                                                                                                    |                                                                                                   | `CASE 項目  

 WHEN 値 THEN 変換値

 WHEN 値 THEN 変換値

 ELSE その他変換値

	END`

---`DECODE(項目,

	値,変換値,  

	値,変換値,  

	その他変換値  

	)`                           | `CASE 項目  

 WHEN 値 THEN 変換値

 WHEN 値 THEN 変換値

 ELSE その他変換値

	END CASE`          | `(case 式  

 (値 式 〜)

 (値 式 〜)

 (otherwise 式 〜)

	)`                  

Choose(項目, 変換値1, 変換値2, 変換値3)
最大 | なし | | | Math.max(値,値) | | | | max(値,値) | max(値,値) | Math.max(値,値) | | Math.max(値,値,…) | | GREATEST(値,値,…) | GREATEST(値,値,…) | (max 値 値 …)
最小 | なし | | | Math.min(値,値) | | | | min(値,値) | min(値,値) | Math.min(値,値) | | Math.min(値,値,…) | | LEAST(値,値,…) | LEAST(値,値,…) | (min 値 値 …)
最大公約数 | | | | | | | | | | | | | | | | (gcd 値 値 …)
最小公倍数 | | | | | | | | | | | | | | | | (lcm 値 値 …)
| MSX-BASIC | VBA | VBS | VB.NET | PASCAL | PL/I | Perl | C言語 | VC++(MFC) | Java | JSP EL | JavaScript | C#(.NET) | SQL(Oracle) | PL/SQL(Oracle) | Lisp
null表現 | なし | Nothing | Nothing | Nothing | nil | | undef | 0NULL) | 0NULL) | null | | `null

	undefined`                                                                                              |                                                                                                   | `NULL`                                                                                                                                                                          | `NULL`                                                                                                  | `nil  

	()`                                                                                

nullチェック | なし | 値 Is Nothing | 値 Is Nothing | 値 Is Nothing | | | | | | 値!=null | | 値!=null | | 値 IS NOT NULL | 値 IS NOT NULL | `(null 値)

	(eq 値 '())`                                                                   

null変換 | なし | | | | | | | 値 ? : <span class="red">0の場合の変換値</span>
(gcc拡張) | | | | | | `NVL(値,

	<span class="red">nullの場合の変換値</span>)`                                                                                                                             | `NVL(値,  

	<span class="red">nullの場合の変換値</span>)`                                                     |                                                                                              
                               |                                                                                                 |                                                                                           |                                                                                           |                                                                                                                 |                                                                                              | `値 ? <span class="aqu">0以外の場合の変換値</span>:<span class="red">0の場合の変換値</span>`                | `値 ? <span class="aqu">0以外の場合の変換値</span> :
	<span class="red">0の場合の変換値</span>`            | `(値!=null) ? <span class="aqu">null以外の場合の値</span> :
	<span class="red">nullの場合の値</span>` |                                                                                                 | `(値!=null) ? <span class="aqu">null以外の場合の値</span> :
	<span class="red">nullの場合の値</span>`     |                                                                                                 | `NVL2(値,  

	<span class="aqu">null以外の場合の変換値</span>,  

	<span class="red">nullの場合の変換値</span>)`                  | NVL2()は使えない                                                                                       |                                                                                                                                                                                
⚠️ **GitHub.com Fallback** ⚠️