JavaScript is a powerful yet quirky language that often surprises developers with its behavior. One such curiosity lies in how null behaves with typeof and instanceof operators. Let’s break it down and understand this in detail.

The Quirk of typeof null

If you’ve ever written this simple line of JavaScript:

console.log(typeof null); // "object"

You might be puzzled by the result. Why does typeof null return “object” when null is clearly not an object?

The answer lies in JavaScript’s early implementation. In the first versions of the language, null was represented as a null pointer — a reference to an object value. This historical design decision led typeof to classify it as an “object”. Over time, this behavior became part of the language specification and was left unchanged for backward compatibility.

However, in reality, null is a primitive type, not an object. While this behavior is considered a bug, it has become a feature we must understand and work with.

Why null instanceof Object is false

Now let’s look at another seemingly confusing piece of code:

console.log(null instanceof Object); // false

Here’s what’s happening:

1. The instanceof operator checks whether the prototype chain of an object includes a specific constructor.

2. In this case, null is a primitive value, not an object, and it doesn’t have a prototype chain.

3. Therefore, instanceof returns false, confirming that null is not an instance of Object.

This behavior aligns with the fact that null is fundamentally different from objects.

Practical Tips for Developers

• When checking for null, avoid relying on typeof. Instead, use a direct equality check:

if (value === null) {
  console.log("Value is null");
}

• To differentiate between null and objects more reliably, use:

if (value === null || typeof value !== "object") {
  console.log("Not an object");
}

Understanding these quirks is crucial for mastering JavaScript and avoiding potential bugs in your code. While these behaviors might feel counterintuitive at first, embracing them as part of the language’s personality can help you write more robust and predictable programs.

Happy coding! 😊

In the global context (outside any function) or inside a regular function (not a method of an object), this refers to the global object, which is window in browsers or global in Node.js.

Object Methods:
When a function is called as a method of an object, this refers to the object that was used to call the method.

Constructors and Classes:
this refers to the newly created object.

Explicitly Setting this with call, apply, and bind:
The call and apply methods allow you to invoke a function with an explicitly defined value for this. The bind method creates a new function that, when called, has a specific value for this.

The Value of this Depends on the Call Context:

• In the global context and regular functions, this refers to the global object (window or global).
• In object methods, this refers to the object itself.
• In constructors and classes, this refers to the newly created object.
• You can explicitly set the value of this using call, apply, and bind.
• Arrow functions capture this from their surrounding lexical context.
• Nested functions can have different values for this, which can be resolved using arrow functions or by saving the context of the outer function. Feel free to ask if you need further assistance!

Explanation

1. Loop Initialization: The loop starts with i initialized to 1 and continues as long as i < 5.
2. Iteration Details:

When i = 1: The condition is true, so it logs 1.

When i = 2: The condition is true, so it logs 2.

When i = 3: The condition is true, but the if (i == 3) continue;statement causes the loop to skip the logging for this iteration.

When i = 4: The condition is true, so it logs 4.

1. Termination: When i becomes 5, the loop terminates since the condition i < 5 is no longer satisfied.

Thus, the output of the code will be

1 2 4

Output Explanation

When you execute arr.flat(1), the flat() method flattens the array to a depth of 1. This means it will flatten only the first level of nested arrays.Original Array Structure:

• The array arr contains:
• 1 (a number)
• 2 (a number)
• [3, 4] (a sub-array)
• [[5], [6]] (a sub-array containing two more sub-arrays)

Flattening Process

1. The first two elements (1 and 2) are kept as they are.
2. The sub-array [3, 4] is flattened into the main array.
3. The last element [[5], [6]] remains unchanged because it is nested deeper than the specified depth of 1.

Thus, the output of the code will be

[1, 2, 3, 4, [5], [6]]

Output Explanation

When you execute arr.flat(1), the flat() method flattens the array to a depth of 1. This means it will flatten only the first level of nested arrays.Original Array Structure:

• The array arr contains:
• 1 (a number)
• 2 (a number)
• [3, 4] (a sub-array)
• [[5], [6]] (a sub-array containing two more sub-arrays)

Flattening Process

1. The first two elements (1 and 2) are kept as they are.
2. The sub-array [3, 4] is flattened into the main array.
3. The last element [[5], [6]] remains unchanged because it is nested deeper than the specified depth of 1.

Thus, the output of the code will be:

[1, 2, 3, 4, [5], [6]]

Spoiler, the console will display:

Hi there, undefined

Why is like that.

1. The sayHi function is defined to take a parameter name.
2. When the function is called with sayHi(), no argument is passed for the nameparameter.
3. In JavaScript, when a function parameter is not provided, it defaults to undefined.
4. The function then returns the string "Hi there, undefined", where ${name} is replaced with the value of name, which is undefined.
5. This returned string is then logged to the console.

Understanding the new Operator in .NET: Creating Object Instances

Learn how the new operator is used to create objects in .NET and the nuances to consider.

Everyone who starts their way in programming gets acquainted with the operator New and learns how it can be used to create instances of a type. However, few people think about how it does it, and what it is capable of. The work of this operator can be divided into several stages:

1. Calculation (how much our object weighs)
2. Allocation (memory for our object)
3. Initialization (creating our object)

Let’s take a closer look at what happens when an object is created by using this operator.

Calculation

First, the number of bytes required to store all instance fields of the type is calculated, which means that it is considered how much all the elements of our instance weigh + 8/16 bytes for the SyncBlock Index & Type Object Pointer.

Example:

class MyExampleClass 
 {
    private string _myString = "String"; 
 }

Our class contains one field of the String type that takes 4 bytes + we add 4 bytes of synchronization block to it and add a pointer to the object type plus 2 bytes for each character that contains our string type field

StringValue = SyncBlock (4) + TypeHandle (4) + m_stringLength (4) + m_firstChar (2) + “String” (12) = 26 bytes.

The extra 2 bytes need for the alignment done by the CLR memory manager.

The main difference is the size of the DWORD, the memory pointer. On 32-bit systems it is 4 bytes, on 64-bit systems it is 8 bytes.

So, if an empty class is equal to only 12 bytes in x86, then in x64 it is already 24 bytes.

Selection

The memory for the object is now allocated, reserving the required number of bytes for the type in the managed heap. The allocated bytes are initialized to zero (0).

As long as there is address space available on the managed heap, the CLR continues to allocate space for new objects, but when it runs out, garbage collection is performed using an optimization mechanism, releasing objects and fragmenting them.

Initialization

Now we need to initialize the pointer to the type object and the synchronization block index and call the type instance constructor with the parameters specified when calling new.

Most compilers automatically include code for calling the base class constructor in the constructor. Each constructor initializes the fields defined in the corresponding type. In particular, the System.Object constructor is called, but it does nothing and simply returns.

Limitation

The new constraint specifies that the type argument in a generic class declaration must have a public parameterless constructor. You can use the new constraint only if the type is not abstract. When using the new() constraint with other constraints, it must be specified last.

Apply the new constraint to a type parameter when the generic class creates new instances of that type. This is shown in the following example:

public class ItemFactory2<T> where T : IComparable, new() 
{  
   // Your code here;
}