Fresh object literals vs variable assignment behavior in Typescript - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of modifying fresh object literals

What is the output of the following TypeScript code?

Typescript

function update(obj: {count: number}) {
  obj.count += 1;
}

const a = {count: 0};
update(a);
update({count: 0});
console.log(a.count);

A 0

B 2

C 1

D TypeError

💡 Hint

Consider which object is actually modified and which is a fresh literal.

The function update increments the count property of the passed object.

When called with a, it modifies a.count from 0 to 1.

When called with a fresh object literal {count: 0}, it modifies that temporary object, but it is discarded immediately.

Therefore, a.count remains 1 after both calls.

❓ Predict Output

intermediate

Effect of variable assignment on object references

What will be logged by the following TypeScript code?

Typescript

const obj1 = {value: 10};
const obj2 = obj1;
obj2.value = 20;
console.log(obj1.value);

A ReferenceError

B 10

C undefined

D 20

💡 Hint

Think about whether obj1 and obj2 point to the same object or different objects.

Both obj1 and obj2 reference the same object in memory.

Changing obj2.value changes the shared object, so obj1.value also reflects the change.

🔧 Debug

advanced

Why does this object mutation not persist?

Consider this TypeScript code snippet. Why does the mutation not affect the original object?

Typescript

function mutate(obj: {x: number}) {
  obj = {x: obj.x + 1};
}

const original = {x: 5};
mutate(original);
console.log(original.x);

A Because the original object is frozen and cannot be changed.

B Because the function reassigns the parameter to a new object, not mutating the original.

C Because the function parameter is passed by value, so changes don't affect the original.

D Because the console.log is called before the mutation happens.

💡 Hint

Look at what happens to the parameter inside the function.

Inside the function, obj is reassigned to a new object. This does not change the original object passed in.

The original object remains unchanged because the function only changes its local parameter reference.

📝 Syntax

advanced

Identify the syntax error in object literal assignment

Which option contains a syntax error when trying to create a fresh object literal with a conditional property?

A const obj = {a: 1, b: 2 if true};

B const obj = {a: 1, b: true ? 2 : 3};

C const obj = {a: 1, ...(true && {b: 2})};

D const obj = {a: 1, ...(false ? {b: 2} : {})};

💡 Hint

Check the syntax for conditional properties inside object literals.

Option A uses invalid syntax b: 2 if true which is not allowed in object literals.

Options A, B, and D use valid JavaScript/TypeScript syntax for conditional properties.

🚀 Application

expert

Predict the final object after multiple assignments and mutations

Given the following TypeScript code, what is the final value of result?

Typescript

let base = {count: 1};
let copy = base;
copy.count = 2;
copy = {count: 3};
base.count = 4;
const result = copy.count + base.count;

A 7

B 3

C 5

D 6

💡 Hint

Track the references and mutations carefully step-by-step.

base and copy initially point to the same object with count: 1.

After copy.count = 2, both see count: 2.

Then copy is reassigned to a new object {count: 3}, but base still points to the original object.

Then base.count = 4 changes the original object.

So copy.count is 3, base.count is 4, sum is 7.