As a side note: you could use an association to store your data:

Associations provide generalizations of symbolically indexed lists, associative arrays, dictionaries, hashmaps, structs, and a variety of other powerful data structures.

Then when you ask for a value that is not yet defined it will return missing:

hash = <||>;
Do[AssociateTo[hash, i -> i], {i, 1, 10, 2}]
Table[If[MissingQ[hash[i]], "No value", hash[i]], {i, 10}]

returns the correct result. This might even be a faster and more flexible solution.

This is not a bug.

ValueQ is HoldAll, meaning the expression that is evaluated is ValueQ[f[i]], which becomes f[1], f[2], etc, which is obviously different from f[i]. (Recall that Table is a dynamic scoping construct, effectively using Block[{i=val},...] to evaluate the expression in its first argument for each value val that i takes). What you want is this:

In[29]:= Table[ With[{i = j}, If[ValueQ[f[i]], f[i], "No value"]], {j, 10}]
Out[29]= {1, "No value", 3, "No value", 5, "No value", 7, "No value", 9, "No value"}

Because With is a lexical scoping construct, which rewrites each instance of i with its value j prior to beginning to evaluate its second argument, this yields the evaluation of ValueQ[f[1]], ValueQ[f[2],] ... and your expected result. An alternative approach is to use Map with a pure function, which against inserts the value of the variable prior to the start of valuation:

In[30]:= If[ValueQ[f[#]], f[#], "No value"] & /@ Range[10]
Out[30]= {1, "No value", 3, "No value", 5, "No value", 7, "No value", 9, "No value"}

Thanks for the explanation. I find writing these things using Map easier anyhow. That's why I also suggested above to use Map over Table in such example.

I didn't know about the nested behaviour of these scopic constructs, thanks for showing.

This is not a bug. ValueQ is a funny function and it's good to be aware what it actually does before attempting to use it. To say that it checks if the expression has a value is inaccurate and can be misleading.

ValueQ[x] will check the OwnValues of x is x is a symbol.

But in all other cases ValueQ simply evaluates its argument and checks if it has evaluated to something that differs from the original.

You can check the implementation:

ValueQ[expr_] := ! Hold[Evaluate[expr]] === Hold[expr]

This of course is problematic in so many ways, e.g. think about what happens if evaluating expr has side effects.

But this behaviour is clearly documented, see under Details in the doc page.

ValueQ gives False only if expr would not change if it were to be entered as Wolfram Language input.

There's a lot of discussion of ValueQ on StackExchange here:

• http://mathematica.stackexchange.com/questions/1474/implementing-a-safe-valueq-that-does-not-evaluate-its-argument

In principle - according to Sanders remark - Trace is already perfectly showing what is going on. One can improve the readability simply by wrapping the output in a "repeated frame" like so:

Framed //@ Trace[Table[If[ValueQ[f[i]], f[i], "No value"], {i, 2}]]

Regards -- Henrik

Excellent - many thanks, Sander!

(As an off topic remark concerning readability: See this discussion).