Javascript 是否可以使用变量！=null而不是变量！==未定义&&；变量！==无效的

我有一些代码，其中一个变量可以是

未定义的

，

空的

，或者一个正常值。无论变量是

未定义

还是

空

，代码都需要执行相同的操作。这样说有危险吗

for (var cur = this.buckets[i]; cur != null; cur = cur.next) {

而不是

for (var cur = this.buckets[i]; cur !== undefined && cur !== null; cur = cur.next) {

下面是完整的程序（讨论中的行位于

HashTable.prototype.walk

）

var hash_seed=Math.floor（Math.random（）*256）；
函数jenkins_散列（键、间隔大小）{
var hash=hash_seed；
对于（VarI=0；I6）；
}
hash+=（hash>11）；
哈希+=（哈希>>0）%interval\u size；
}
//构造函数，获取要创建的存储桶数
函数哈希表（大小）{
this.bucket=新数组（大小）；
}
//私有方法，忽略
HashTable.prototype.\u位置=函数（键）{
var index=jenkins_散列（key，this.bucket.length）；
var cur=this.bucket[索引]；
如果（cur==未定义）{
返回{i:index，cur:null，prev:null}；
}
var-prev=cur；
对于（；cur！==null；cur=cur.next）{
if（cur.key==key）{
返回{i:index，cur:cur，prev:prev}；
}
prev=cur；
}
返回{i:index，cur:cur，prev:prev}；
};
//将值与哈希中的键关联
HashTable.prototype.store=函数（键、值）{
var r=该位置（键）；
如果（r.prev==null）{
这个.桶[r.i]={
key:key，value:value，next:null
};
返回；
}
如果（r.cur！==null）{
r、 cur.value=值；
返回；
}
r、 上一页下一页={
key:key，value:value，next:null
};
返回；
};
//获取与键关联的值
//如果密钥不在散列中，则返回undefined
HashTable.prototype.fetch=函数（键）{
var r=该位置（键）；
如果（r.cur==null）{
返回未定义；
}
返回r.cur.value；
};
//如果密钥在散列中，则返回true
//如果密钥不在哈希中，则返回false
HashTable.prototype.exists=函数（键）{
var r=该位置（键）；
返回r.cur！==null；
};
//从散列中删除密钥
HashTable.prototype.delete=函数（键）{
var r=该位置（键）；
如果（r.cur==null）{
返回；
}
如果（r.cur==r.prev）{
this.bucket[r.i]=r.cur.next；
}
r、 prev.next=r.cur.next；
};
//从散列中删除所有键
HashTable.prototype.clear=函数（）{
变量长度=this.bucket.length；
this.bucket=新数组（长度）；
};
//为散列中的每个键/值对运行一个函数
//函数签名应该是函数（k，v）{}
//警告：正在使用此方法时将密钥添加到哈希
//运行可能会导致意外的结果
HashTable.prototype.walk=函数（func）{
for（var i=0；i”+v）}）；
的语义=定义良好。如果与
null
比较，则：


如果“cur”是
未定义的
或
null
，则结果是
false
如果“cur”是其他值，则结果为
true

“抽象”相等比较（如严格比较）首先检查每个操作数的类型（请注意，这与
typeof
返回的不同！）。
null
的类型为null类型，
undefined
的类型为undefined类型。抽象比较算法明确地认为
undefined
和
null
相等

因此，对
null
和
undefined
进行自己的显式检查是毫无意义的。（当然，如果需要与语言中内置的抽象比较不同的逻辑，您可能需要单独检查。）
只需使用
在比较中添加注释=运算符是正确的-我认为这就足够了。话虽如此，我不确定这是否真的需要SO来回答。@Qantas94Heavy如果我必须添加一条注释以使其他程序员明白，那么我可能应该将其更改为后者。这并不是说它不清楚（正如Pointy所说，算法在规范中）-这是因为他们可能会认为你只想比较null，而不是未定义和null。男孩，我在试图为此总结
===
时是否混淆了自己：-）如果我正确阅读了你写的内容，那么就没有危险：这两个语句在功能上是相同的（我可以忽略编辑发出的警告）.@Chas.Owens是的，我只是补充了一些东西。
var hash_seed = Math.floor(Math.random() * 256);

function jenkins_hash(key, interval_size) {
    var hash = hash_seed;
    for (var i=0; i<key.length; ++i) {
        hash += key.charCodeAt(i);
        hash += (hash << 10);
        hash ^= (hash >> 6);
    }
    hash += (hash << 3);
    hash ^= (hash >> 11);
    hash += (hash << 15);
    // make unsigned and modulo interval_size
    return (hash >>> 0) % interval_size;
}

//constructor, takes the number of buckets to create
function HashTable(size) {
    this.buckets = new Array(size);
}

//private method, ignore
HashTable.prototype._position = function(key) {
    var index = jenkins_hash(key, this.buckets.length);
    var cur   = this.buckets[index];

    if (cur === undefined) {  
          return { i: index, cur: null, prev: null };
    }

    var prev = cur;
    for (; cur !== null; cur = cur.next) {
        if (cur.key == key) {
            return { i: index, cur: cur, prev: prev };
        }
        prev = cur;
    }

    return { i: index, cur: cur, prev: prev };
};

// associate a value with a key in the hash
HashTable.prototype.store = function(key, value) {
    var r = this._position(key);
    if (r.prev === null) {  
          this.buckets[r.i] = {
              key: key, value: value, next: null  
          };
          return;
    }

    if (r.cur !== null) {
        r.cur.value = value;
        return;
    }

    r.prev.next = {
        key: key, value: value, next: null  
    };
    return;
};

// fetches the value associated with the key
// returns undefined if the key is not in the hash
HashTable.prototype.fetch = function(key) {
    var r = this._position(key);
    if (r.cur === null) {
        return undefined;
    }

    return r.cur.value;
};

// returns true if the key is in the hash
// returns false if the key isn't in the hash
HashTable.prototype.exists = function(key) {
    var r = this._position(key);
    return r.cur !== null;
};

// removes a key from the hash
HashTable.prototype.delete = function(key) {
    var r = this._position(key);
    if (r.cur === null) {
        return;  
    }
    if (r.cur === r.prev) {
        this.buckets[r.i] = r.cur.next;  
    }
    r.prev.next = r.cur.next;
};

// removes all keys from the hash
HashTable.prototype.clear = function() {
    var length   = this.buckets.length;
    this.buckets = new Array(length);
};

// run a funciton for every key/value pair in the hash
// function signature should be function(k, v) {}
// WARNING: adding keys to the hash while this method is
// running may lead to unexpected results
HashTable.prototype.walk = function(func) {
    for (var i = 0; i < this.buckets.length; i++) {
        for (var cur = this.buckets[i]; cur != null; cur = cur.next) {
            func(cur.key, cur.value);
        }  
    }  
};

// returns all of the keys in the hash
HashTable.prototype.keys = function() {
    var keys = [];
    this.walk(function(k,v) { keys.push(k) });
    return keys;
};

// run a function for every key/value pair in the hash
// function signature should be function(k, v) {}
// WARNING: only keys in the hash when the method is called
// will be visited; however, changes to their values will be
// reflected
HashTable.prototype.safer_walk = function(func) {
    var keys = this.keys();
    for (var i = 0; i < keys.length; i++) {
        func(keys[i], this.fetch(keys[i]));
    }
}

var h = new HashTable(101);

h.store("abc", 5);
h.store("def", 6);
h.walk(function(k, v) { console.log(k + " => " + v) });