#typeof

Answer:  When it’s a “QueryColumn”.

I was dumping a ColdFusion struct using a new CFDumpLite custom tag/UDF that I’m developing and I came across an issue that had been causing me a problem for a while.  I was looping over SQL query column names to auto-generate a struct.  The code looked something like this:

<CFSET MyStruct = StructNew()> <CFLOOP LIST="#myQuery.ColumnList#" INDEX="thisColumn">     <CFSET MyStruct[thisColumn] = myQuery[thisColumn]> </CFLOOP>

NOTE:  Apparently Adobe added their own QueryGetRow() function that mimics this behavior in CF11.

When dumped using CFDump, it looked like regular keys and simple text values... but using isSimpleValue() would return “no” as the underlying data type was detected as “coldfusion.sql.QueryColumn“.  (I identified this by outputting MyStruct[thisColumn].getClass().getName().toString(). Normally values are returned as java.lang.String, java.lang.Integer or java.sql.Date.

If I set the variables manually using dot notation, the values are detected as “simple strings”:

MyStrucy.Column1Name = myQuery.Column1Name

SOLUTION: In order to get the assignment via the loop to function as expected, I had to indicate that I wanted the result in the “first row”...

<CFSET MyStruct[thisColumn] = myQuery[thisColumn][1]>

The most frustrating thing is that I wasn’t able to initially determine why my script wasn’t working as expected.  It looked like a “simple value”, but ColdFusion refused to identify it as such.  It still looked like a simple value when using CFDump, but some validation I was using ignored the values because it was being detected as “QueryColumn” instead of string, integer, date, etc.

C# | Generic Converter

There are times when we need to dynamically convert/parse the object from its string value to its type.

Below is the generic converter code which we can use instead of creating method for each type.

SomeType temp; var strVal = "StringValueofObject"; var converter = TypeDescriptor.GetConverter(typeof(temp)); temp = (SomeType)converter.ConvertFromString(strVal);

It basically gets the…

The sizeof operator in C tells us how much space the result of an expression would use if we were to evaluate it, but doesn't actually evaluate the expression. For example, sizeof i++ yields the size of the variable i, but doesn't increment i. Many implementations of C provide a typeof operator too, which provides the type of an expression without evaluating it.

That lack of side-effects is useful, for example in macro hygiene. Preprocessor macros have surprising behaviour when invoked with arguments that have side-effects:

#define BAD_MACRO(arg) do { \ /* Aiee, what if someone uses BAD_MACRO(i++)? */ \ printf("%i squared is %i\n", arg, arg * arg); \ } while (0) #define GOOD_MACRO(arg) do { \ typeof (arg) local; /* 'arg' not evaluated, no side-effects */ \ local = arg; /* 'arg' evaluated exactly once, here */ \ printf("%i squared is %i\n", local, local * local); \ } while (0)

Now that's a pretty well known pitfall, and it's common practice to use typeof and sizeof to avoid side-effects this way. But C has one more surprise lying in wait for the unwary: sometimes sizeof and typeof do have side-effects! C supports declaring arrays whose length is determined at run time, e.g.:

void do_something(int i) { char working_array[i]; /* ... */ }

The length of the working array depends on the value of i. And of course we can ask the compiler to tell us the size of a dynamic array, too: sizeof (char[i]) is equivalent to i * sizeof char, and will be evaluated at run time.

We can use any integer expression to specify the length of the array, even one with side-effects. If we do that, the compiler has no (reliable) way to know the size without evaluating the whole expression, including its side-effects. So that's what it does:

int i = 0; printf("%ld\n", sizeof (char[++i]));

increments i and prints "1". More generally, sizeof will evaluate any array-size expression in its argument if the final size depends on the value of the expression. Worse than that, according to the spec, sizeof may evaluate such expressions even if it doesn't have to:

Where a size expression is part of the operand of a sizeof operator and changing the value of the size expression would not affect the result of the operator, it is unspecified whether or not the size expression is evaluated.

Here, "unspecified" means the compiler may choose to do it or not and doesn't even have to document which. That is to say:

/* Not a size expression: won't increment i. */ sizeof (++i); /* Size expression that affects the final size: will increment i. */ sizeof (char[++i]); /* Size expression that doesn't affect the final size (a pointer to * an array is the same size regardless of the size of the array). * May or may not increment i! */ sizeof (char(*)[++i]);

When to use GetType() and typeof?

Hello Readers,

Both GetType() and typeof are used for checking the type of the object.

[bctt tweet=”When to use GetType() and typeof?” username=”dotnetcrunchh”]

typeof is an operator to obtain a type known at compile-time (or at least a generic type parameter).

The operand of typeofis always the name of a type or type parameter – never an expression with a value (e.g. a variable). See the C#…

The void operator evaluates any expression and returns undefined. This sounds useless, but there are actually two valid use cases. Firstly, undefined can actually be assigned to:

var testLocalRedefine = function() { var undefined = 'not undefined'; console.log(undefined);// not undefined console.log(typeof undefined === 'undefined');// false } testLocalRedefine();

Assigning to the global undefined is prevented in most environments, but the problem of local scope assigns still exists (even under strict mode). So now checking if a variable is undefined cannot be done using the undefined keyword, but that can be bypassed entirely by using typeof:

var testNoKeywordUndefined = function() { var a; console.log(a === undefined);// true var undefined = 'not undefined'; console.log(a === undefined);// false console.log(typeof a === 'undefined');// true } testNoKeywordUndefined();

But that still leaves no way to explicitly assign an undefined value. Which is where void comes in:

var testSetToUndefined = function() { var a = 'test'; var undefined = 'not undefined'; a = undefined; console.log(a);// not undefined a = void 0; console.log(a);// undefined } testSetToUndefined();

Anything could have been put into place instead of 0, that is just a standard convention. Anyways, that is a pretty obscure case especially considering that global undefined is prevented in most environments. But still an informative exercise.

The second valid case is in minification. void 0 is 6 characters while undefined is 9, so it may make sense to replace undefined with void 0 when minifying very large projects.