Synthetic events in React - Performance & Optimization

Performance: Synthetic events

MEDIUM IMPACT

Synthetic events affect how user interactions are handled and can impact input responsiveness and event processing speed.

Handling user clicks efficiently in React

React

function Button() {
  return <button onClick={() => console.log('Clicked')}>Click me</button>;
}

Avoids unnecessary event persistence, allowing React to reuse event objects and optimize memory.

📈 Performance GainReduces memory overhead and keeps event handling fast and responsive.

Handling user clicks efficiently in React

React

function Button() {
  return <button onClick={(e) => { e.persist(); console.log('Clicked'); }}>Click me</button>;
}

Calling e.persist() disables React's event pooling, increasing memory usage and delaying garbage collection.

📉 Performance CostIncreases memory usage and can cause minor delays in event processing under heavy interaction.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Using React synthetic events normally	No extra DOM ops	0	0	[OK] Good
Calling e.persist() on synthetic events	No extra DOM ops	0	0	[!] OK - higher memory use
Using native DOM events directly in React	No extra DOM ops	0	0	[!] OK - bypasses React pooling
Heavy event handler logic inside synthetic events	No extra DOM ops	0	0	[X] Bad - slows input responsiveness

Rendering Pipeline

Synthetic events are created by React to normalize events across browsers. When a user interacts, React captures the native event, wraps it in a synthetic event, and passes it to handlers. This adds a small step before the event reaches your code.

→Event Handling

→JavaScript Execution

⚠️ BottleneckJavaScript Execution due to event object creation and pooling management

Core Web Vital Affected

INP

Synthetic events affect how user interactions are handled and can impact input responsiveness and event processing speed.

Optimization Tips

1Avoid calling e.persist() unless you need to keep the event beyond the handler.

2Keep event handlers simple and fast to improve input responsiveness.

3Use React synthetic events to benefit from cross-browser normalization with minimal overhead.

Performance Quiz - 3 Questions

What is the main performance cost of React synthetic events compared to native events?

A They add a small JavaScript processing step to normalize events.

B They cause extra DOM reflows on every event.

C They increase CSS selector complexity.

D They block rendering until the event finishes.

DevTools: Performance

How to check: Record a performance profile while interacting with the component. Look for event handler execution time and memory usage.

What to look for: Check if event handlers are quick and if there is excessive memory retained due to event persistence.

Practice

1. What is the main purpose of React's SyntheticEvent?

easy

A. To provide a consistent event interface across different browsers

B. To replace native DOM events with custom events

C. To speed up event handling by skipping the event queue

D. To allow events only on class components

Solution

1. Step 1: Understand SyntheticEvent role

   React's SyntheticEvent wraps native browser events to normalize differences across browsers.

2. Step 2: Compare options

   To provide a consistent event interface across different browsers correctly states the purpose. Options A, C, and D are incorrect because SyntheticEvent does not replace native events, does not skip event queues, and works with functional components too.

3. Final Answer:

   To provide a consistent event interface across different browsers -> Option A

4. Quick Check:

   SyntheticEvent = consistent cross-browser event [OK]

Hint: SyntheticEvent normalizes events across browsers [OK]

Common Mistakes:

• Thinking SyntheticEvent replaces native events
• Believing SyntheticEvent only works with class components
• Assuming SyntheticEvent speeds up event handling

2. Which of the following is the correct way to attach a click event handler in React using Synthetic events?

easy

A. Click me

B. Click me

C. Click me

D. Click me

Solution

1. Step 1: Recall React event naming conventions

   React uses camelCase for event handlers, so the correct attribute is onClick.

2. Step 2: Check each option

   <button onClick={handleClick}>Click me</button> uses onClick correctly. <button onclick={handleClick}>Click me</button> uses lowercase onclick which is invalid in JSX. <button OnClick={handleClick}>Click me</button> has incorrect capitalization. <button on-click={handleClick}>Click me</button> uses hyphen which is invalid.

3. Final Answer:

   <button onClick={handleClick}>Click me</button> -> Option C

4. Quick Check:

   React event handlers use camelCase like onClick [OK]

Hint: React events use camelCase like onClick [OK]

Common Mistakes:

• Using lowercase event names like onclick
• Using hyphens in event names
• Incorrect capitalization like OnClick

3. Consider this React code snippet:

function MyButton() {
  function handleClick(event) {
    alert(event.type);
  }
  return <button onClick={handleClick}>Click me</button>;
}

What will be alerted when the button is clicked?

medium

A. undefined

B. click

C. onClick

D. Click

Solution

1. Step 1: Understand event.type in SyntheticEvent

   The event.type property contains the type of the event, which for a click event is the string "click" in lowercase.

2. Step 2: Analyze the alert output

   When the button is clicked, handleClick is called and alerts event.type, so it shows "click".

3. Final Answer:

   click -> Option B

4. Quick Check:

   event.type for click event = "click" [OK]

Hint: event.type is lowercase event name like 'click' [OK]

Common Mistakes:

• Assuming event.type is capitalized
• Confusing event handler name with event.type
• Expecting undefined if event not passed

4. Identify the error in this React event handler code:

function Form() {
  function handleSubmit(event) {
    event.preventdefault();
    console.log('Submitted');
  }
  return <form onSubmit={handleSubmit}><button type="submit">Send</button></form>;
}

medium

A. Missing return statement in handleSubmit

B. The event handler should be named onsubmit, not onSubmit

C. The button type should be button, not submit

D. event.preventdefault() should be event.preventDefault() with capital D

Solution

1. Step 1: Check event method spelling

   The method to stop form submission is event.preventDefault() with a capital D. The code uses lowercase 'd', which causes an error.

2. Step 2: Verify other parts

   The event handler should be named onsubmit, not onSubmit is wrong because React uses camelCase onSubmit. The button type should be button, not submit is incorrect because submit button type is correct. Missing return statement in handleSubmit is irrelevant since no return needed in handler.

3. Final Answer:

   event.preventdefault() should be event.preventDefault() with capital D -> Option D

4. Quick Check:

   Method names are case-sensitive: preventDefault() [OK]

Hint: JavaScript method names are case-sensitive [OK]

Common Mistakes:

• Using lowercase preventdefault() instead of preventDefault()
• Confusing onSubmit with onsubmit
• Changing button type unnecessarily

5. You want to handle a keyboard event in React and only respond when the Enter key is pressed. Which is the best way to do this using Synthetic events?

function Input() {
  function handleKeyDown(event) {
    // What condition should go here?
  }
  return <input onKeyDown={handleKeyDown} />;
}

hard

A. if (event.key === 'Enter') { /* handle Enter */ }

B. if (event.code === 13) { /* handle Enter */ }

C. if (event.keyCode === 13) { /* handle Enter */ }

D. if (event.keyName === 'Enter') { /* handle Enter */ }

Solution

1. Step 1: Understand SyntheticEvent keyboard properties

   React SyntheticEvent supports event.key which returns the key name as a string, e.g., 'Enter'. This is preferred over deprecated keyCode.

2. Step 2: Evaluate options

   if (event.key === 'Enter') { /* handle Enter */ } uses event.key === 'Enter' which is modern and recommended. if (event.keyCode === 13) { /* handle Enter */ } uses keyCode which is deprecated. Options A, B, and D use deprecated or invalid properties.

3. Final Answer:

   if (event.key === 'Enter') { /* handle Enter */ } -> Option A

4. Quick Check:

   Use event.key === 'Enter' for keyboard checks [OK]

Hint: Use event.key with string names, not keyCode [OK]

Common Mistakes:

• Using deprecated event.keyCode
• Using invalid event.code or event.keyName
• Comparing keyCode to string instead of number