标签: comparison-operators

今天只有我注意到并发现了使用===运算符的重要性.您可以在以下示例中看到它:

$var=0;
if ($var==false) echo "true"; else echo "false";  //prints true
$var=false;
if ($var==false) echo "true"; else echo "false";  //prints true
$var=0;
if ($var===false) echo "true"; else echo "false";  //prints false
$var=false;
if ($var===false) echo "true"; else echo "false";  //prints true 

问题是,是否有任何使用===运算符而不是使用==运算符的情况？

我正在编写代码的一部分,我有一个看起来像的数组[[data]].将data通过Django的模板引擎渲染在服务器端.所以我的代码看起来像这样:

var data = {{ series|safe }}; 
// data will be [[]] if no data is present
if (data ==[[]])
  console.log('no data');

将if始终返回false.这意味着在[[]] == [[]],false而我的测试表明[]==[]也是false如此.

任何描述将不胜感激.

Python是否定义了"NaN> 0"的值？在我的Python解释器中,我得到:

>>> float('nan') > 0
False

但这有保证吗？

如果我理解正确,IEEE 754标准将任何涉及NaN的比较赋予False.但是,我在Python文档中找不到任何表明遵循此标准的内容.我甚至明白1/0,在IEEE 754下应该给无限,但是Python引发了异常(ZeroDivisionError),所以Python并没有完全遵循IEEE 754.

那么,是float('nan') > 0在Python 中完全定义的结果吗？我需要知道在所有平台上以及所有版本的Python(包括旧版本)是否相同.

python是否支持链接is运算符,如下所示？

a = None
b = None
a is b is None

这个输出True,一些文档引用会很好.

我正在golang中进行一个简单的链表实现,用于学习目的.元素的定义如下:

type Element struct {
    next, prev *Element
    Value      interface{}
}

如您所见,Value可以是满足空接口的任何东西.现在,作为一个新功能,我想这样做,当你在列表中插入一个新元素时,它会以排序的方式插入它 - 每个元素将<=下一个.

为了做到这一点,我写了以下方法:

func (l *LinkedList) Add(val interface{}) *Element {
    this := &l.Root
    e := Element{Value: val}
    for {
        if this.next.Value != nil && this.next.Value < val {  // <-comparison here
            this = this.next
        } else {
            return l.insert(&e, this)
        }
    }
}

编译器抱怨operator < not defined on interface哪个是公平的.所以我理解在我的Element typedef中,我应该将Value限制为可以使用<运算符进行比较的类型.我在研究golang不支持运算符重载的问题时学到了这一点 - 我不是想这样做.相反,我只是想确保Element.Value是一个可以使用<运算符进行比较的类型.我该怎么做呢？

更新:

在我看来,简单地定义基于内置的新类型可能并不困难,可以通过某种功能进行比较.所以我写了这个烂摊子(以及其他尝试做同样事情的方法):

type Comparable interface {
    LessThan(j interface{}) bool // …

如果使用默认实现创建virtualC++20 三路比较运算符，则编译器会默默地创建一个 virtual ，如在子类中重写它所示：<=>operator==

struct A { 
    virtual std::strong_ordering operator <=>(const A &) const = default; 
};
struct B : A {
    virtual bool operator==(const A&) const noexcept override;
};

所有三个主要编译器的行为都是如此，演示：https://gcc.godbolt.org/z/nvaf94M51

它是标准规定的还是只是一种常见的实施实践？

作为一个侧面观察，在 C++20 中我们也有能力创建consteval立即虚拟函数，如果扩展示例：

#include <compare>

struct A { 
    virtual consteval std::strong_ordering operator <=>(const A &) const = default; 
};

struct B : A {
    virtual consteval bool operator==(const A&) const noexcept override { return false; }
};

int main() {
    static …

如果数据库行是这样的:country = 'usa'我查询"select * from data where country = 'usa '"它也返回此行.所以它不完全匹配.

为什么MySQL会这样做？而在其他情况下,当它不是真的时,它也将返回TRUE？

在C++中,==和!=的优先级高于按位AND,XOR和OR的基本原理是什么？

这似乎对我来说更自然的事operator==和operator!=跟从operator&,operator^和operator|.我想了解动机,以便我能更好地记住订购.

例如,我认为以下类型的用法很常见:

if (bitFields & value == 0) { // Incorrect test.
  // Do Something.
}

由于==结果是1或0,为什么你要将它用于按位运算？相反,上述内容必须写成:

if ((bitFields & value) == 0) { // Correct test.
  // Do Something.
}

在比较为零之前获得按位AND的预期含义.

#include <compare>
#include <iostream>

int main()
{ 
   auto comp1 = 1.1 <=> 2.2;
   auto comp2 = -1 <=> 1;
   std::cout << typeid(comp1).name()<<"\n"<<typeid(comp2).name();
}

输出：

结构 std::partial_ordering
结构 std::strong_ordering

我知道如果操作数具有整数类型，则运算符将返回一个 prvalue 类型std::strong_ordering。我也知道操作数是否有浮点类型，运算符会产生类型的纯右值std::partial_ordering。

但是为什么我应该使用三向比较运算符而不是双向运算符（==, !=, <, <=, >, >=）？这对我有什么好处吗？

我正在学习和使用 Python，我想出了以下测试代码（请注意，我不会编写这样的高效代码，但在学习新语言时，我喜欢尝试该语言的极端情况）：

a = None    
print(None == a) # I expected True, I got True

b = 1
print(None == b) # I expected False, I got False

class MyNone:
    # Called if I compare some myMyNone == somethingElse
    def __eq__(self, __o: object) -> bool:
        return True

c = MyNone()
print (None == c) # !!! I expected False, I got True !!!

请参阅代码示例的最后一行。

None == something明明不存在的东西怎么会None返回True呢？我本希望得到这样的结果something == None，但不是None == …