Are you worried about the possibility the dynamic object will have a custom equality operator that will change the way the null is interpreted? If so just use Object.ReferenceEquals if (Object.ReferenceEquals(null, param)) { ……. }
Ordered comparison between a pointer and an integer is ill-formed in C++ (even when the integer is a null pointer constant such as it is in this case). The risk is that compilers are allowed to, and do, refuse to compile such code. You can rewrite it as either of these: if(myPtr != nullptr) if(myPtr)
As long as TypeScript doesn’t support this natively, you could write a function similar to this one: function throwExpression(errorMessage: string): never { throw new Error(errorMessage); } which would then allow you to throw an error as expression: const myString = nullableVariable ?? throwExpression(“nullableVariable is null or undefined”)
You can do it using Reflection bool IsAnyNullOrEmpty(object myObject) { foreach(PropertyInfo pi in myObject.GetType().GetProperties()) { if(pi.PropertyType == typeof(string)) { string value = (string)pi.GetValue(myObject); if(string.IsNullOrEmpty(value)) { return true; } } } return false; } Matthew Watson suggested an alternative using LINQ: return myObject.GetType().GetProperties() .Where(pi => pi.PropertyType == typeof(string)) .Select(pi => (string)pi.GetValue(myObject)) .Any(value => string.IsNullOrEmpty(value));
I’m purposely only checking against null because I don’t want to restrict a ValueType from being equal to its default(T) That is a good insight, but don’t worry, you are already covered there. It is not legal to compare a T against default(T) using == in the first place; overload resolution will not find a … Read more
An “undefined variable” is different from the value undefined. An undefined variable: var a; alert(b); // ReferenceError: b is not defined A variable with the value undefined: var a; alert(a); // Alerts “undefined” When a function takes an argument, that argument is always declared even if its value is undefined, and so there won’t be … Read more
They are not equivalent. The first will execute the block following the if statement if myVar is truthy (i.e. evaluates to true in a conditional), while the second will execute the block if myVar is any value other than null. The only values that are not truthy in JavaScript are the following (a.k.a. falsy values): … Read more
Using a juggling-check, you can test both null and undefined in one hit: if (x == null) { If you use a strict-check, it will only be true for values set to null and won’t evaluate as true for undefined variables: if (x === null) { You can try this with various values using this … Read more