Skip to content
Subscribe to RSS Find me on GitHub Follow me on Twitter

Creating a 7-Segment Display with JavaScript


In this blog post, we will explore the process of creating a 7-segment display using JavaScript. A 7-segment display is a type of electronic display that can represent numbers and characters by illuminating or deactivating seven individual segments. It is commonly used in various applications, including digital clocks, calculators, and electronic signage.

The importance of understanding how to create a 7-segment display with JavaScript lies in its potential applications in web development. By incorporating this type of display into our websites or web applications, we can enhance the user experience and provide visually appealing and interactive elements.

Throughout this blog post, we will guide you through the steps of setting up the HTML structure, styling the display using CSS, implementing the necessary JavaScript logic, and displaying numbers and characters on the 7-segment display. We will also discuss how to create interactive features, such as buttons or input fields, to enable user input and enhance interactivity.

By the end of this blog post, you will have a solid understanding of how to create a custom 7-segment display using JavaScript, and you will be encouraged to explore and experiment with different designs and functionalities to suit your specific web development needs.

What is a 7-Segment Display?

A 7-segment display is a widely used electronic display device that is capable of displaying numbers and some characters. It consists of seven LED segments arranged in a specific pattern, with each segment representing a specific part of a number or character. The segments are labeled from "a" to "g" and can be individually controlled to turn on or off, allowing different combinations to form numbers and characters.

The seven segments are arranged in a shape similar to the number "8", with one horizontal segment in the middle and three segments on each side. The segments can be turned on or off to represent different numbers or characters. By selectively turning on the appropriate segments, different digits and characters can be displayed.

For example, to display the number "1", segments "b" and "c" are turned on, while the other segments remain off. To display the letter "A", segments "a", "b", "c", "e", "f", and "g" are turned on, while segment "d" remains off.

In web development, a 7-segment display can be created using HTML, CSS, and JavaScript to provide a visually appealing way to display numbers and characters on a webpage. By mapping each numeric or character value to the appropriate segments, developers can create custom displays to suit their specific needs.

Setting up the HTML Structure

To create a 7-segment display with JavaScript, we first need to set up the HTML structure. This involves creating the necessary HTML elements that will represent each segment of the display.

We can start by creating a <div> element that will serve as the container for our 7-segment display. We can give it an ID, such as "display-container", for easy reference in our JavaScript code.

Inside the container, we will create individual <div> elements for each segment of the display. There are seven segments in total, including the top, middle, bottom, and four side segments. We can give each segment its own ID or class for styling and control purposes.

Here's an example of how the HTML structure for a simple 7-segment display may look like:

<div id="display-container">
  <div class="segment" id="segment-top"></div>
  <div class="segment" id="segment-top-left"></div>
  <div class="segment" id="segment-top-right"></div>
  <div class="segment" id="segment-middle"></div>
  <div class="segment" id="segment-bottom-left"></div>
  <div class="segment" id="segment-bottom-right"></div>
  <div class="segment" id="segment-bottom"></div>

In the example above, we have created a container <div> with the ID "display-container". Inside it, we have created seven individual <div> elements, each representing a segment of the 7-segment display. Each segment has been given a unique ID or class, such as "segment-top" and "segment-bottom-left", which we can later reference in our JavaScript code.

Once we have set up the HTML structure, we can move on to styling the display using CSS.

Styling the Display

To create the appearance of the 7-segment segments, we can use CSS to define the styles for each segment. Each segment can be represented using a div element with appropriate dimensions and positioning.

To achieve a visually appealing display, we can apply appropriate colors and proportions to the segments. For example, we can use different background colors to distinguish between the segments and give them a vibrant look. We can also adjust the width and height of each segment to ensure they are proportional and visually pleasing.

Here is an example of how we can style the segments using CSS:

.segment {
  width: 30px;
  height: 100px;
  background-color: #ff0000; /* red color */
  border-radius: 5px;
} {
  margin-top: 10px;

.segment.middle {
  margin-top: 5px;

.segment.bottom {
  margin-bottom: 10px;

In this example, we have defined a CSS class called "segment" which represents a single segment of the 7-segment display. We have set the width and height to appropriate values, and applied a red background color. The border-radius property gives the segments rounded corners for a smoother appearance.

We have also used additional CSS classes, such as "top", "middle", and "bottom", to style specific segments differently. These classes can be applied to the appropriate div elements within the HTML structure.

By applying appropriate colors and proportions, we can create a visually appealing 7-segment display that is easy to read and interact with.

Implementing the JavaScript Logic

To create a functional 7-segment display, we need to write JavaScript functions that control the segments and respond to user input. This section will cover the basic logic behind these functions.

First, we need to assign variables to each segment of the display. We can use JavaScript's querySelector method to select the segments by their corresponding CSS classes or IDs. For example:

const segmentA = document.querySelector('.segment-a');
const segmentB = document.querySelector('.segment-b');
// ...

Next, we can write a function to turn on or off each segment based on a given input. We can use CSS classes to control the appearance of the segments. For example, to turn on segment A, we would add a class called "active" to its corresponding HTML element:

function turnOnSegmentA() {

function turnOffSegmentA() {

To respond to user input and update the display, we can use event listeners. For example, if we have a button element with the ID "btn-toggle-segment-a", we can add a click event listener to toggle the state of segment A:

const toggleSegmentAButton = document.getElementById('btn-toggle-segment-a');

toggleSegmentAButton.addEventListener('click', () => {
  if (segmentA.classList.contains('active')) {
  } else {

In this example, when the button is clicked, it checks if segment A is currently active. If it is, the turnOffSegmentA function is called to turn off the segment. If it isn't active, the turnOnSegmentA function is called to turn on the segment.

By writing similar functions for each segment and setting up appropriate event listeners, we can control the display based on user input and update it accordingly.

Keep in mind that this is a basic example, and depending on your specific requirements, you may need to implement additional logic or functionality.

Displaying Numbers and Characters

In order to display numbers and characters on the 7-segment display, we need to map each value to the appropriate segments. Each segment corresponds to a specific number or character, and by turning on or off the segments, we can display the desired information.

To achieve this, we can create a mapping object that associates each number or character with the segments it requires. For example, the number "0" would require segments a, b, c, d, e, f to be turned on, while the number "1" would only require segments b and c.

Here's an example mapping object for the numbers 0 to 9:

const segmentMapping = {
  0: ['a', 'b', 'c', 'd', 'e', 'f'],
  1: ['b', 'c'],
  2: ['a', 'b', 'g', 'e', 'd'],
  3: ['a', 'b', 'g', 'c', 'd'],
  4: ['f', 'g', 'b', 'c'],
  5: ['a', 'f', 'g', 'c', 'd'],
  6: ['a', 'f', 'g', 'c', 'd', 'e'],
  7: ['a', 'b', 'c'],
  8: ['a', 'b', 'c', 'd', 'e', 'f', 'g'],
  9: ['a', 'b', 'c', 'd', 'f', 'g']

Once we have the mapping object, we can create a function that takes a number or character as input and turns on or off the corresponding segments. This function will update the display to show the desired information.

Here's an example function that displays a number on the 7-segment display:

function displayNumber(number) {
  const segments = segmentMapping[number];
  // Turn on the segments for the given number
  segments.forEach(segment => {
  // Turn off all other segments
  Object.keys(segmentMapping).forEach(key => {
    if (key !== number) {
      segmentMapping[key].forEach(segment => {

In this function, we iterate over the segments required for the given number and add the 'on' class to their corresponding HTML elements. We also iterate over all other numbers in the mapping object and turn off their segments by removing the 'on' class.

By calling this function with the desired number as input, we can dynamically update the 7-segment display to show different numbers or characters.

Creating Interactive Features

In order to make our 7-segment display more interactive, we can add buttons or input fields to enable user input. This allows users to directly control what is displayed on the display.

One option is to add buttons that correspond to each segment of the display. When a user clicks on a button, we can toggle the state of the segment, turning it on or off. This allows users to manually control which segments are displayed and create custom numbers or characters.

Another option is to add an input field where users can enter a specific value. We can then use JavaScript to parse the input and update the display accordingly. This allows users to enter numbers or characters directly and see them displayed on the 7-segment.

To enhance the interactivity of the display, we can also incorporate animations or transitions. For example, when a segment is turned on or off, we can add a fade-in or fade-out effect to make the change smoother and more visually appealing. We can also add transitions to the display when it updates with a new value, creating a more dynamic and engaging user experience.

By adding buttons or input fields and incorporating animations or transitions, we can make our 7-segment display more interactive and allow users to have more control over what is displayed. This enhances the overall user experience and makes the display more engaging and enjoyable to use.


In this blog post, we have explored the process of creating a 7-segment display using JavaScript. We started by understanding what a 7-segment display is and how it represents numbers and characters. Then, we went through the steps of setting up the HTML structure and styling the display using CSS to achieve an appealing visual appearance.

Next, we implemented the JavaScript logic by writing functions to control the segments and used event listeners to update the display based on user input. We also discussed how to map numeric and character values to the appropriate segments, allowing us to display desired information on the 7-segment.

Furthermore, we looked into creating interactive features by adding buttons or input fields for user input and incorporating animations or transitions to enhance the display's interactivity.

In conclusion, creating a custom 7-segment display with JavaScript opens up a world of possibilities for developers. By experimenting and exploring different techniques and designs, you can create unique and engaging displays for various applications. So, go ahead and start exploring the exciting world of custom 7-segment displays!