What is JSX? Why React.js uses JSX?

What is JSX? Why React.js uses JSX?

In the realm of modern web development, particularly when working with React.js, you’ll often encounter JSX. Understanding this powerful syntax extension is pivotal to developing intuitive and maintainable React applications. In this article, we’ll explore what JSX is, why React.js has adopted it, and delve into its syntax and nuances to enable you to harness its full potential.

Understanding JSX

JSX, which stands for JavaScript XML, is a syntax extension for JavaScript. At first glance, it may look like a blend of HTML and JavaScript due to its tag-based structure, but there’s more to it than meets the eye.

Consider the following JSX example:

const element = <h1>Hello, codedamn community!</h1>;

This might look like HTML, but it’s JSX. One of the standout features of JSX is its capability to simplify UI component creation. Instead of having separate templates or using string-based methods to create HTML content, developers can write a more readable and expressive code right within their JavaScript, leading to a more integrated and efficient development experience.

JSX in React.js

React.js is a widely acclaimed JavaScript library for building interactive user interfaces. But why did React choose JSX as its templating language?

React’s philosophy is centered around the component-based architecture. Each UI piece is a component, and these components interact and nest within each other to form a complete application. JSX seamlessly aligns with this philosophy, allowing developers to write these components in a declarative and visually intuitive manner.

Some benefits of using JSX in React development include:

  1. Readability: JSX code is often more readable, especially for those familiar with HTML.
  2. Performance: JSX compiles down to optimized JavaScript functions, ensuring faster rendering.
  3. Safety: JSX prevents injection attacks as it escapes any values embedded in it by default.

JSX Syntax

The syntax of JSX might seem familiar to those who’ve worked with HTML, but there are some crucial differences:

  1. Self-closing tags: Just like in XML, if an element doesn’t have children, you must close it with a />.
    const image = <img src="path_to_image.jpg" alt="Description" />;
  2. CamelCase in attribute names: In JSX, you use camelCase for attributes instead of the hyphenated names you find in HTML. For instance, tabindex in HTML becomes tabIndex in JSX.
    const inputField = <input tabIndex="1" />;
  3. Dynamic content with curly braces: You can embed any JavaScript expression within curly braces.
    let greeting = "Hello";
    const greetElement = <h1>{greeting}, codedamn!</h1>;

JSX Expressions

One of the most powerful features of JSX is the ability to embed JavaScript expressions directly within the code using curly braces {}. This enables dynamic rendering of content.

Consider this example:

const user = {
firstName: "John",
lastName: "Doe"

const welcomeMessage = <h1>Welcome back, {user.firstName} {user.lastName}!</h1>;

Here, the JavaScript object user is used within the JSX to render a dynamic welcome message.

JSX and Components

In React, JSX plays an indispensable role in creating components. Each JSX element you create translates into a React component, whether it’s a built-in component like a <div> or a custom component.

Let’s look at how to define a simple React component using JSX:

function Welcome(props) {
return <h1>Hello, {props.name}</h1>;

const element = <Welcome name="codedamn" />;

Here, Welcome is a functional component that takes in props as its argument and returns a JSX element. When rendering the Welcome component, we pass a prop called name, making our code both modular and dynamic.

JSX and Props

JSX, standing for “JavaScript XML”, is a syntax extension for JavaScript. It offers a way to describe what the UI should look like in a syntax that is visually closer to HTML. One of the most powerful features of JSX is its capability to pass props (short for properties) to React components.

Props in React are a way of passing data from parent to child components. They are read-only and help components to be reusable. Using JSX, passing props feels very natural, similar to adding attributes to an HTML tag.


function Welcome(props) {
return <h1>Hello, {props.name}</h1>;

const element = <Welcome name="codedamn" />;
ReactDOM.render(element, document.getElementById('root'));

In the above code, we pass a name prop to the Welcome component using JSX.


While JSX might look a lot like HTML at first glance, there are some crucial differences to be aware of:

  1. className vs. class: In JSX, due to class being a reserved keyword in JavaScript, we use className instead of class to assign CSS classes.
  2. Inline styles: In JSX, inline styles are not strings. They are objects with camelCased properties.


const divStyle = {
color: 'blue',
backgroundColor: 'white'

<div style={divStyle}>Hello codedamn!</div>

React handles these JSX-specific conventions behind the scenes, providing a seamless developer experience.

JSX Transpilation

JSX is not natively understood by browsers. Hence, before the browser can run the code, JSX needs to be transformed into regular JavaScript. This process is known as transpilation.

Tools like Babel play an essential role in this transformation. Babel takes in JSX code and outputs plain JavaScript which browsers can understand. In the context of a modern web development workflow, tools like Webpack often couple with Babel to both bundle multiple files together and transpile JSX.

Benefits of Using JSX

Several benefits come with using JSX in React development:

  1. Readability: JSX code closely resembles the layout structure, making it easier for developers to understand the structure and visual representation of the UI components.
  2. Maintainability: As components grow and become more complex, JSX keeps them readable and maintainable.
  3. Performance Optimizations: React can optimize JSX during the transpilation process, which can result in performance benefits in certain scenarios.

For instance, at codedamn, using JSX has allowed us to build complex UIs with components that are both efficient and easy to understand, aiding in faster development and iterations.

JSX Best Practices

While JSX is forgiving, it’s essential to follow some best practices to ensure clean and efficient code:

  1. Always close tags: Unlike some cases in HTML, JSX requires all elements to be closed.
  2. Component Naming: Always use PascalCase for React component names. This helps distinguish them from regular HTML tags.
  3. Formatting: Use tools like Prettier to auto-format and maintain consistent code styling across your JSX files.


JSX, with its blend of JavaScript and markup-like syntax, has undeniably revolutionized the way developers write UI code in React. By abstracting away the complex JavaScript logic needed to create elements and components, JSX makes React development more intuitive and efficient. We highly encourage budding developers at codedamn and beyond to dive deep into JSX and leverage its powers in their React projects.

Additional Resources

  1. React Official Documentation on JSX
  2. Babel: Learn more about how Babel transpiles JSX


Sharing is caring

Did you like what Mehul Mohan wrote? Thank them for their work by sharing it on social media.


No comments so far