Was variable x ever true?

In Javascript, is there a good way to check if a variable was ever a true, (or any value), in the entire session? The best way I can think of right now is to perform a regular check like this, recording开发者_运维百科 the truthiness in another variable:

if (variable){
  variablewasevertrue = true;
}

Then when I want to know if the original variable was ever true, I check if the new variablewasevertrue is true or undefined. There's nothing more graceful like if (variable was ever true){ is there? That doesn't seem very Javascript-y.

No there is no if (variable was ever true) facility in the language. Variables store values, not history.

Intercepting values as they're assigned and checking is the only way to do it. If the variable is really a property (e.g. a global variable is a property of the global object) you can intercept changes easily using setters.

So to have a history keeping global variable you could do

var hasEverBeenTruthy = false;
(function () {
  var value;
  Object.defineProperty(window, "myGlobal", {
    "get": function () { return value; },
    "set": function (newval) {
      if (newval) { hasEverBeenTruthy = true; }
      value = newval;
    }
  });
})();

This will work on modern browsers, and there are __defineSetter__ variants on many older browsers.

Variables store value, not a history of a memory location. If you want to do something like this, I would suggest you use an Object of some sort:

var x = {
    value: false,
    history: [],
    set: function(val){
        history.push(this.value);
        this.value = val;
    },
    wasEver: function(val){
        return this.history.indexOf(val) >= 0;
    }
};

Then you can use the object like so:

x.set(false);
x.value; //returns false

x.set(true);
x.value; //returns true

x.wasEver(true); // returns true
x.wasEver(false); //returns true
x.wasEver("hello"); //returns false

This gives each object it's own history (as in, it can check multiple values, not just one - as with the getter/setter stuff mentioned in other answers), and is guaranteed to work in any scope, as all functionality is contained within the defined object.

No, except that you could use a getter and setter like this, which delegates the setting of a variable so that you can check whether it is to set at one time:

var value,
    wasevertrue = false;

window.__defineSetter__('test', function(v) {
    value = v;
    wasevertrue = wasevertrue || (v === true);
});

window.__defineGetter__('test', function() {
    return value;
});

Now,

test = false; // wasevertrue === false
test = true;  // wasevertrue === true
test = false; // wasevertrue === true

Better yet would be putting this in a closure because you can now just set value = true as a workaround to the setter.

no - there is no state tracking on variables. it is only whatever its current value is. beyond that its your own custom implementation using property-like methods for state tracking.

Have another variable called "wasevertrue = false." Anywhere you set "variable" immediately follow it with a check that sees if variable == true. If it is, set wasevertrue = true.

You can't use a single scalar variable to track history, but you could use an array. It's not ideal, but it's an alternative:

function setVar(arr, value) {
    arr.unshift(value);
    return arr;
}

function getVar(arr) {
    return arr[0];
}

function checkHist(arr, histValue) {
    var ii;
    for (ii = 0; ii < arr.length; ii++) {
        if (arr[ii] === histValue) {
            return true;
        }
    }
    return false;
}

var myVar = [];
myVar = setVar(myVar, true);
myVar = setVar(myVar, false);

alert(checkHist(myVar, true)); // alerts "true"