Is it permissible to use the variable! = Null instead of the variable! == undefined && variable! == null?

Question

I have code where a variable can be undefined , null or a normal value. The code should do the same, regardless of whether the variable is undefined or null . Is there a danger to say

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

instead

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

The full program is below (the corresponding line is in HashTable.prototype.walk ).

 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[ri] = { 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[ri] = 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) }); 

Answer 1

Semantics != Clearly defined. If you are comparing with null , then:

• If "cur" is undefined or null , then the result is false
• If "cur" is something else, then the result is true

A comparison of abstract equality (e.g. strict comparison) first checks the type of each operand (which is clearly visible, different from what typeof returns!). Type null is type Null and type undefined is type Undefined. The abstract comparison algorithm explicitly considers undefined and null equal.

Thus, there really is no point in doing your own explicit check for both null and undefined . (You may want to test separately if you need logic other than the abstract comparison built into the language.)