timers: add hasRef method to Timeout & Immediate

doc/api/timers.md

@@ -23,6 +23,16 @@ running as long as the immediate is active. The `Immediate` object returned by
 [`setImmediate()`][] exports both `immediate.ref()` and `immediate.unref()`
 functions that can be used to control this default behavior.
 
+### immediate.hasRef()
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {boolean}
+
+Used to check whether the `Immediate` object will keep the Node.js event loop
+active.
+
 ### immediate.ref()
 <!-- YAML
 added: v9.7.0
@@ -61,6 +71,16 @@ timer is active. Each of the `Timeout` objects returned by these functions
 export both `timeout.ref()` and `timeout.unref()` functions that can be used to
 control this default behavior.
 
+### timeout.hasRef()
+<!-- YAML
+added: REPLACEME
+-->
+
+* Returns: {boolean}
+
+Used to check whether the `Timeout` object will keep the Node.js event loop
+active.
+
 ### timeout.ref()
 <!-- YAML
 added: v0.9.1

lib/timers.js

@@ -547,6 +547,10 @@ Timeout.prototype.ref = function() {
   return this;
 };
 
+Timeout.prototype.hasRef = function() {
+  return !!this[kRefed];
+};
+
 Timeout.prototype.close = function() {
   clearTimeout(this);
   return this;
@@ -622,7 +626,7 @@ function processImmediate() {
     count++;
     if (immediate[kRefed])
       refCount++;
-    immediate[kRefed] = undefined;
+    immediate[kRefed] = null;
 
     tryOnImmediate(immediate, tail, count, refCount);
 
@@ -713,6 +717,10 @@ const Immediate = class Immediate {
     }
     return this;
   }
+
+  hasRef() {
+    return !!this[kRefed];
+  }
 };
 
 function setImmediate(callback, arg1, arg2, arg3) {
@@ -761,7 +769,7 @@ exports.clearImmediate = function clearImmediate(immediate) {
 
   if (immediate[kRefed] && --immediateInfo[kRefCount] === 0)
     toggleImmediateRef(false);
-  immediate[kRefed] = undefined;
+  immediate[kRefed] = null;
 
   if (destroyHooksExist()) {
     emitDestroy(immediate[async_id_symbol]);

test/parallel/test-timers-immediate-unref.js

@@ -3,6 +3,14 @@
 const common = require('../common');
 const Countdown = require('../common/countdown');
 
+const assert = require('assert');
+
+const immediate = setImmediate(() => {});
+assert(immediate.hasRef());
+immediate.unref();
+assert(!immediate.hasRef());
+clearImmediate(immediate);
+
 // This immediate should execute as it was unrefed and refed again.
 // It also confirms that unref/ref are chainable.
 setImmediate(common.mustCall(firstStep)).ref().unref().unref().ref();

test/parallel/test-timers-unref.js

@@ -23,15 +23,21 @@
 
 const common = require('../common');
 
+const assert = require('assert');
+
 let unref_interval = false;
 let unref_timer = false;
 let checks = 0;
 
 const LONG_TIME = 10 * 1000;
 const SHORT_TIME = 100;
 
+const timer = setTimeout(() => {}, 10);
+assert(timer.hasRef());
 // Should not throw.
-setTimeout(() => {}, 10).unref().ref().unref();
+timer.unref().ref().unref();
+assert(!timer.hasRef());
+
 setInterval(() => {}, 10).unref().ref().unref();
 
 setInterval(common.mustNotCall('Interval should not fire'), LONG_TIME).unref();