标签: equality

我在C#中有一个Address类,如下所示:

public class Address
{            
    public string StreetAddress { get; set; }
    public string RuralRoute { get; set; }
    public string City { get; set; }
    public string Province { get; set; }
    public string Country { get; set; }
    public string PostalCode { get; set; }
}

我正在实现相等性,所以我需要覆盖哈希码.起初我打算使用EJ的哈希码公式,但后来我想:这些都是字符串字段,我不能只使用StringBuilder连接它们并从该字符串返回哈希码？

那是:

var str = new StringBuilder();
str.Append(StreetAddress)
   .Append(RuralRoute)
   ...

return str.ToString().GetHashCode();

这有什么优点/缺点？我为什么不这样做？

我正在为一位同事写一个有启发性的例子,告诉他为什么测试花车的平等往往是个坏主意.我去的例子是添加0.1十次,对1.0(我在我的介绍数值类所示)进行比较.我惊讶地发现两个结果是相同的(代码+输出).

float @float = 0.0f;
for(int @int = 0; @int < 10; @int += 1)
{
    @float += 0.1f;
}
Console.WriteLine(@float == 1.0f);

一些调查表明,这个结果不能依赖(很像浮动平等).我发现最令人惊讶的是在其他代码之后添加代码可能会改变计算结果(代码+输出).请注意,此示例具有完全相同的代码和IL,并附加了一行C#.

float @float = 0.0f;
for(int @int = 0; @int < 10; @int += 1)
{
    @float += 0.1f;
}
Console.WriteLine(@float == 1.0f);
Console.WriteLine(@float.ToString("G9"));

我知道我不应该在花车上使用平等,因此不应该太在意这一点,但我发现它非常令人惊讶,就像我向大家证明的那样.做的东西后,您进行了计算改变了先前计算的价值？我不认为这是人们通常在脑海中计算的模型.

我不是完全难住了,似乎是安全的假设,有某种优化的改变计算的结果,"平等"的情况下发生的(建筑在调试模式防止"平等"的情况下).显然,当CLR发现稍后需要将浮动框打包时,优化​​被放弃.

我搜索了一下但找不到这种行为的原因.任何人都能提醒我吗？

我有一个问题,我很困惑.我在Android应用程序中有以下几行代码:

System.out.println(CurrentNode.getNodeName().toString());
if (CurrentNode.getNodeName().toString() == "start") {
    System.out.println("Yes it does!");
} else {
    System.out.println("No it doesnt");
}

当我查看第一个println语句的输出时,它在LogCat中显示为"start"(显然没有引号).但是当if语句执行时,它会转到else语句并输出"No it does not".

我想知道节点的名称是否可能有某种非打印字符,所以我检查了来自getNodeName()的字符串的长度,它是5个字符长,正如您所期望的那样.

有谁知道这里发生了什么？

如果我想比较XMlDocument的内容,它是这样的吗？

XmlDocument doc1 = GetDoc1();
XmlDocument doc2 = GetDoc2();

if(doc1 == doc2)
{

}

我不检查它们是否是相同的对象引用,但是如果xml的CONTENTS是相同的.

如果我尝试这样的事情:

$(".foo") === $(".foo") // = false

......我弄错了.如果我改为尝试此查询,

$(".foo").get(0) === $(".foo").get(0) // = true

......我明白了.

那是因为:

{a:myObject} !== {a:myObject};
[myObject]   !== [myObject];
myObject     === myObject;

我想知道是否有任何简洁的方法来测试这种相等性,最好是内置到jQuery中.我写的第二种方法只有在最多只有一个匹配的元素时才能正常工作.foo.该解决方案适用于任何数量的元素.

显然我不想只检查,".foo" === ".foo"因为我使用的实际选择更复杂.我只是为这个例子简化了它们.(例如,我可能想检查$(this)是否选择了相同的东西$(".foo").)

我试图定义一个函数,它将获取一个Double -> Double函数并返回其数学导数.我尝试过以下操作:

der :: (Double -> Double) -> (Double -> Double)
der f
    | f == exp = exp
    | otherwise = undefined

但哈斯克尔不支持==的Double -> Double值.我在Haskell尝试做什么是不可能的？

我有一个错误,我在使用时依赖于彼此相等的方法is.事实证明并非如此:

>>> class What(object):
    def meth(self):
        pass

>>> What.meth is What.meth
False
>>> inst = What()
>>> inst.meth is inst.meth
False

为什么会这样？它适用于常规功能:

>>> def func():
    pass

>>> func is func
True

根据Python文档:"在定义时__eq__(),还应该定义__ne__()操作符将按预期运行".

然而,似乎Python的计算__ne__为not __eq__自动:

In [8]: class Test:
    def __eq__(self, other):
        print("calling __eq__")
   ...:         return isinstance(other, Test)
   ...:

In [9]: a = Test()

In [10]: b = Test()

In [11]: a == b
calling __eq__
Out[11]: True

In [12]: a != b
calling __eq__
Out[12]: False

In [13]: a == 1
calling __eq__
Out[13]: False

In [14]: a != 1
calling __eq__
Out[14]: True

那么定义__ne__它是否恰好是return not self.__eq__(other)什么意义呢？而且,这种行为实际记录在哪里？ …

考虑以下代码.

object str = new string(new char[] { 't', 'e', 's', 't' });
object str1 = new string(new char[] { 't', 'e', 's', 't' });
Console.WriteLine(str==str1); // false
Console.WriteLine(str.Equals(str1));  // true

我理解在这里工作的相等运算符,因为我们已经隐式地转换为对象,等于运算符检查两者的引用是否相等并返回false.

但我对第二个问题感到困惑,返回true看起来它正在调用String类型提供的Equals覆盖实现,并且如果它们相等则检查字符串的内容.

我的问题是它为什么不检查运算符的内容相等性,它们的实际类型是字符串而不是对象.对 ？

以下代码输出两者:

object str = "test";
object str1 = "test";
Console.WriteLine(str==str1); // true
Console.WriteLine(str.Equals(str1)); // true

我能想到的测试数组arr中所有元素是否相等的最短路径是all(arr[1] .== arr).虽然这当然很短,但似乎有点不雅.是否有内置功能可以做到这一点？

我怀疑有一些东西==(arr...),但这不起作用,因为==操作员只能采取两个参数.我不确定Julia如何解析表达式arr[1] == arr[2] == arr[3],但有没有办法让它适应具有任意数量元素的数组？