blocks|key|1054673|text|JavaScript的祖先可以追溯到C，而C没有逻辑XOR运算符。主要是因为它没有用。按位异或非常有用，但在我多年的编程工作中，我从未需要过逻辑XOR。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1054674|如果您有两个布尔变量，您可以使用以下命令模拟XOR：|1054675|if+(a+!=+b)|code-block|syntax|javascript|1054676|对于两个任意变量，您可以使用!将它们强制转换为布尔值，然后使用相同的技巧：|offset|length|style|CODE|1054677|if+(!a+!=+!b)|1054678|然而，这是相当晦涩的，当然也值得一提。实际上，您甚至可以在这一点上使用逐位XOR运算符，尽管这对我来说太聪明了：|1054679|if+(!a+%5E+!b)|1054680|entityMap^0|0|0|0|E|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

JavaScript traces its ancestry back to C, and C does not have a logical XOR operator. Mainly because it's not useful. Bitwise XOR is extremely useful, but in all my years of programming I have never needed a logical XOR.

If you have two boolean variables you can mimic XOR with:

<pre><code>if (a != b)
</code></pre>

With two arbitrary variables you could use <code>!</code> to coerce them to boolean values and then use the same trick:

<pre><code>if (!a != !b)
</code></pre>

That's pretty obscure though and would certainly deserve a comment. Indeed, you could even use the bitwise XOR operator at this point, though this would be far too clever for my taste:

<pre><code>if (!a ^ !b)
</code></pre>

blocks|key|839994|text|Javascript有一个按位XOR运算符：%5E|type|unstyled|depth|inlineStyleRanges|entityRanges|data|839995|var+nb+=+5%5E9+//+=+12|code-block|syntax|javascript|839996|你可以将它与布尔值一起使用，它会给出0或1的结果(你可以将其转换回布尔值，例如result+=+!!(op1+%5E+op2))。但正如约翰所说，它等同于result+=+(op1+!=+op2)，后者更清晰。|offset|length|style|CODE|839997|entityMap^0|0|0|13|M|23|L|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Javascript has a bitwise XOR operator : ^

<pre><code>var nb = 5^9 // = 12
</code></pre>

You can use it with booleans and it will give the result as a 0 or 1 (which you can convert back to boolean, e.g. <code>result = !!(op1 ^ op2)</code>). But as John said, it's equivalent to <code>result = (op1 != op2)</code>, which is clearer.

blocks|key|1054876|text|两个布尔值的XOR只是看它们是否不同，因此：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1054877|Boolean(a)+!==+Boolean(b)|code-block|syntax|javascript|1054878|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The XOR of two booleans is simply whether they are different, therefore:

<pre><code>Boolean(a) !== Boolean(b)
</code></pre>

blocks|key|840321|text|转换为布尔值，然后执行xor，如-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|840322|!!a+%5E+!!b|code-block|syntax|javascript|840323|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Covert to boolean and then perform xor like -

<pre><code>!!a ^ !!b
</code></pre>

blocks|key|1054606|text|有..。某种程度上：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1054607|if(+foo+?+!bar+:+bar+)+{
++...
}|code-block|syntax|javascript|1054608|或者更容易阅读：|1054609|if(+(+foo+&&+!bar+)+%7C%7C+(+!foo+&&+bar+)+)+{
++...
}|1054610|为什么？不知道。|1054611|因为javascript开发人员认为它是不必要的，因为它可以由其他已经实现的逻辑运算符来表示。|1054612|你也可以只使用带nand的gon，这就是它，你可以通过它来进行其他所有可能的逻辑操作。|1054613|我个人认为它从基于c的语法语言驱动而来是有历史原因的，据我所知，xor并不存在，或者至少非常罕见。|1054614|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

there is... sort of:

<pre><code>if( foo ? !bar : bar ) {
 ...
}
</code></pre>

or easier to read:

<pre><code>if( ( foo &amp;&amp; !bar ) || ( !foo &amp;&amp; bar ) ) {
 ...
}
</code></pre>

why? dunno. 

because javascript developers thought it would be unnecessary as it can be expressed by other, already implemented, logical operators.

you could as well just have gon with nand and thats it, you can impress every other possible logical operation from that.

i personally think it has historical reasons that drive from c-based syntax languages, where to my knowledge xor is not present or at least exremely uncommon.

blocks|key|1054824|text|可以，只需执行以下操作。假设您正在处理布尔值A和B，那么可以使用以下公式在JavaScript中计算AXORB值|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1054825|var+xor1+=+!(a+===+b);|code-block|syntax|javascript|1054826|前一行也等同于下面的代码|1054827|var+xor2+=+(!a+!==+!b);|1054828|就我个人而言，我更喜欢xor1，因为我必须键入较少的字符。我相信xor1也更快。它只是执行两次计算。xor2正在执行三个计算。|1054829|视觉解释..。阅读下面的表格(其中0代表false，1代表true)并比较第3列和第5列。|1054830|!(A+===+B)：|1054831|%7C+A+%7C+B+%7C+A+XOR+B+%7C+A+===+B+%7C+!(A+===+B)+%7C
------------------------------------------
%7C+0+%7C+0+%7C++++0++++%7C++++1++++%7C++++++0+++++%7C
%7C+0+%7C+1+%7C++++1++++%7C++++0++++%7C++++++1+++++%7C
%7C+1+%7C+0+%7C++++1++++%7C++++0++++%7C++++++1+++++%7C
%7C+1+%7C+1+%7C++++0++++%7C++++1++++%7C++++++0+++++%7C
------------------------------------------|1054832|好好享受吧。|1054833|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Yes, Just do the following.
Assuming that you are dealing with booleans A and B, then A XOR B value can be calculated in JavaScript using the following

<pre><code>var xor1 = !(a === b);
</code></pre>

The previous line is also equivalent to the following

<pre><code>var xor2 = (!a !== !b);
</code></pre>

Personally, I prefer xor1 since I have to type less characters. I believe that xor1 is also faster too. It's just performing two calculations. xor2 is performing three calculations.

Visual Explanation ... Read the table bellow (where 0 stands for false and 1 stands for true) and compare the 3rd and 5th columns.

!(A === B):

<pre><code>| A | B | A XOR B | A === B | !(A === B) |
------------------------------------------
| 0 | 0 | 0 | 1 | 0 |
| 0 | 1 | 1 | 0 | 1 |
| 1 | 0 | 1 | 0 | 1 |
| 1 | 1 | 0 | 1 | 0 |
------------------------------------------
</code></pre>

Enjoy.

blocks|key|1055193|text|一个用于布尔值的线条：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1055194|if+(x+?+!y+:+y)+{+do+something+cool+}|code-block|syntax|javascript|1055195|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

One liner for Boolean:
<pre><code>if (x ? !y : y) { do something cool }
</code></pre>

blocks|key|1055152|text|为了后人着想，而且因为我发现这是一个很好的练习，所以您可以很容易地通过XOR运算符利用真实性来强制执行。就像选择的答案一样，它可能有点太聪明了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1055153|const+xor+=+(a,+b)+=>+!!(!!a+%5E+!!b)

console.log(undefined+%5E+{})+//+Returns+0,+bitwise+can't+be+done+here.
console.log(xor(undefined,+{}))+//+Returns+true,+because+{}+is+truthy+and+undefined+is+falsy
console.log(0+%5E+1)+//+Works+naturally,+returns+1
console.log(xor(0,+1))+//+Also+works,+returns+true
console.log(true+%5E+false)+//+Again,+returns+true
console.log(xor(true,+false))+//+And+again,+returns+true...|code-block|syntax|javascript|1055154|有趣的是，这应该在TypeScript中起作用，通过强制显式的any：|1055155|const+xor+=+(a:+any,+b:+any)+=>+!!((!!a+as+any)+%5E+(!!b+as+any))|1055156|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

For posterity's sake, and because I found this to be a good exercise, you can leverage truthiness with the XOR operator quite easily to coerce. Like the chosen answer, it's probably a bit too clever.
<pre><code>const xor = (a, b) =&gt; !!(!!a ^ !!b)

console.log(undefined ^ {}) // Returns 0, bitwise can't be done here.
console.log(xor(undefined, {})) // Returns true, because {} is truthy and undefined is falsy
console.log(0 ^ 1) // Works naturally, returns 1
console.log(xor(0, 1)) // Also works, returns true
console.log(true ^ false) // Again, returns true
console.log(xor(true, false)) // And again, returns true...
</code></pre>
And for fun, this should work in TypeScript, by forcing explicit any:
<pre><code>const xor = (a: any, b: any) =&gt; !!((!!a as any) ^ (!!b as any))
</code></pre>

blocks|key|840252|text|之所以没有逻辑XOR+(%5E%5E)，是因为与&&和%7C%7C不同，它不提供任何惰性逻辑优势。也就是说，必须计算右侧和左侧的两个表达式的状态。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|840253|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The reason there is no logical XOR (^^) is because unlike &amp;&amp; and || it does not give any lazy-logic advantage. That is the state of both expressions on the right and left have to be evaluated.

blocks|key|840278|text|cond1+xor+cond2相当于cond1+%2B+cond+2+==+1：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|840279|这就是证据：|840280|​|840281|let+ops+=+[[false,+false],[false,+true],+[true,+false],+[true,+true]];

function+xor(cond1,+cond2){
++return+cond1+%2B+cond2+==+1;
}

for(op+of+ops){
++console.log(`${op[0]}+xor+${op[1]}+is+${xor(op[0],+op[1])}`)
}|code-block|syntax|javascript|840282|840283|entityMap^0|0|F|I|J|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|Y|8|@]|D|@]|E|$M|N]]|$1|O|3|I|5|6|7|Z|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|Q|$]]

<code>cond1 xor cond2</code> is equivalent to <code>cond1 + cond 2 == 1</code>: 

Here's the proof :

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let ops = [[false, false],[false, true], [true, false], [true, true]];

function xor(cond1, cond2){
 return cond1 + cond2 == 1;
}

for(op of ops){
 console.log(`${op[0]} xor ${op[1]} is ${xor(op[0], op[1])}`)
}</code></pre>
</div>
</div>

blocks|key|1055072|text|嘿，我找到了这个解决方案，在JavaScript和TypeScript上进行make和XOR。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1055073|if(+%2B!!a+%5E+%2B!!b+)
{
++//This+happens+only+when+a+is+true+and+b+is+false+or+a+is+false+and+b+is+true.
}
else
{
++//This+happens+only+when+a+is+true+and+b+is+true+or+a+is+false+and+b+is+false
}|code-block|syntax|javascript|1055074|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Hey I found this solution, to make and XOR on JavaScript and TypeScript.
<pre><code>if( +!!a ^ +!!b )
{
 //This happens only when a is true and b is false or a is false and b is true.
}
else
{
 //This happens only when a is true and b is true or a is false and b is false
}
</code></pre>

blocks|key|1054761|text|试试这个短小且易于理解的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1054762|function+xor(x,y){return+true==(x!==y);}

function+xnor(x,y){return+!xor(x,y);}|code-block|syntax|javascript|1054763|这将适用于任何数据类型|1054764|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Try this short and easy to understand one

<pre><code>function xor(x,y){return true==(x!==y);}

function xnor(x,y){return !xor(x,y);}
</code></pre>

This will work for any data type

Why is there no logical xor in JavaScript?

问为什么JavaScript中没有逻辑xor？
EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么JavaScript中没有逻辑xor？EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么JavaScript中没有逻辑xor？
EN