成人毛片一区二区,300部国产真实乱

In this article, we’ll create an iOS-inspired toggle React component. This will be a small, self-contained component that you can reuse in future projects. As we go, we’ll also build a simple demo React app that uses our custom toggle switch component.

Although we could use third-party libraries for this, building the component from scratch allows us to better understand how our code works and allows us to customize our component completely.

The checkbox is traditionally used for collecting binary data, such as?yes?or?no,?true?or?false,?enable?or?disable,?on?or?off, etc. Although some modern interface designs avoid form fields when creating toggle switches, I’ll stick with them here due to their greater accessibility.

Here’s a screenshot of the component we’ll be building:

Create a Toggle Switch in React as a Reusable Component

Key Takeaways

Use Create React App to quickly set up a new React application and build a reusable iOS-inspired toggle switch component.
Leverage SCSS for styling the toggle switch, ensuring it’s visually appealing and aligns with modern design standards.
Implement the toggle switch as a controlled component in React, using props to manage its state and behavior dynamically.
Enhance accessibility by making the toggle switch keyboard accessible and using appropriate ARIA attributes.
Utilize PropTypes for type-checking within the component to ensure that the required data is passed and is of the correct type.
Explore advanced theming and responsiveness by incorporating SCSS variables and media queries to adapt the toggle switch’s appearance on different devices.

Step 1 – Creating the React App

Let’s use Create React App to quickly get a toggle switch React component up and running. If you’re unfamiliar with Create React App, check out our?getting started guide.

create-react-app toggleswitch

Once everything has been installed, change into the newly created directory and start the server with?yarn start?(or?npm start?if you prefer). This will start the development server at?http://localhost:3000.

Next, create a?ToggleSwitch?directory in the?src?directory. This is where we will make our component:

mkdir src/ToggleSwitch

In this directory, make two files:?ToggleSwitch.js?and?ToggleSwitch.scss:

touch ToggleSwitch.js ToggleSwitch.scss

Finally, alter?App.js?as follows:

import React from 'react';
import ToggleSwitch from './ToggleSwitch/ToggleSwitch'

function App() {
  return (
    <ToggleSwitch />
  );
}

export default App;

Step 2 – The Markup

We can start by setting up a basic HTML checkbox input form element for our toggle React component with its necessary properties.

create-react-app toggleswitch

Then, add an enclosing?

tag around it and a tag right below the tag to create a label saying, Toggle Me!

mkdir src/ToggleSwitch

Adding everything, you should get something like this:

We can also get rid of the label text and use the??tag itself to check or uncheck the checkbox input control. For that, add two??tags inside the? tag to construct the switch holder and the toggling switch:

touch ToggleSwitch.js ToggleSwitch.scss

Step 3 – Converting to a React Component

Now that we know what needs to go into the HTML, all we need to do is convert the HTML into a React component. Let’s start with a basic component here. We’ll make this a class component, and then we’ll convert it into hooks, as it’s easier for new developers to follow?state?than?useState when building a React switch button.

Add the following to?src/ToggleSwitch/ToggleSwitch.js file we created in the step 1.

import React from 'react';
import ToggleSwitch from './ToggleSwitch/ToggleSwitch'

function App() {
  return (
    <ToggleSwitch />
  );
}

export default App;

At this point, it’s not possible to have multiple toggle switch sliders on the same view or page due to the repetition of?ids. Although we could leverage React’s way of componentization here, we’ll be using?props?to dynamically populate the values:

<input type="checkbox" name="name"  />

The?this.props.Name?will populate the values of?id,?name?and?for?(note that it is?htmlFor?in React JS) dynamically, so that you can pass different values to the component and have multiple instances on the same page.

If you noticed, the??tag doesn’t have an ending??tag. Instead, it’s closed in the starting tag like?, which is completely fine in JSX.

You can test this component by updating the App.js with the below code.

<div >
  <input type="checkbox"  name="toggleSwitch"  />
  <label  for="toggleSwitch">
    Toggle Me!
  </label>
</div>

Inspect the output at http://localhost:3000/ (possibly using your browser’s dev tools) and ensure everything is working correctly.

Step 4 – Styling and SCSS

I recently wrote about?styling React Components, where I compared the various ways this was possible. In that article, I concluded that SCSS is the best method, and that’s what we’ll use here.

For SCSS to work with Create React App, you’ll need to install the?sass package.

Note: Previously, many developers used node-sass for this. But, node-sass library has now been deprecated and it is recommended to use sass or sass-embedded.

<div >
  <input type="checkbox"  name="toggleSwitch"  />
  <label  for="toggleSwitch">
    <span ></span>
    <span ></span>
  </label>
</div>

We’ll also need to import the correct file into our component:

create-react-app toggleswitch

Now for the styling. This is a rough outline of what we’re after for the styling of our React switch button.

By default, the switch is only?75px?wide and vertically aligned?in an inline-block?so that it’s inline with the text and doesn’t cause layout problems.
We’ll ensure the control is not selectable so that users can’t drag and drop it.
We’ll be hiding the original checkbox input.
Both the?::after?and?::before?pseudo-elements need to be styled and made into elements to get them into the DOM and style them.
We’ll also add some CSS transitions for a cool animated effect.

And this is what that looks like in SCSS. Add the following to?src/ToggleSwitch/ToggleSwitch.scss:

mkdir src/ToggleSwitch

Now, run the server again at?http://localhost:3000/,?and you’ll see four nicely styled toggle switches. Try toggling them; they should all work.

Also, take a while to go through the code above. If there’s anything you’re unsure about, you can consult the?Sass documentation, or ask a question at the?SitePoint Forums.

Dynamic Labels

Currently, the toggle options are hard coded:

touch ToggleSwitch.js ToggleSwitch.scss

To make the component more flexible, we can grab these dynamically from the control using?HTML5 data-attributes:

import React from 'react';
import ToggleSwitch from './ToggleSwitch/ToggleSwitch'

function App() {
  return (
    <ToggleSwitch />
  );
}

export default App;

We’ll hardcode the data attributes for testing but will make this more flexible in the final version:

<input type="checkbox" name="name"  />

If you run the application, you should see something like this:

Step 6 – Creating a Smaller Component Version

Also, using a smaller version of the switch component React without the text for smaller screens would be a great idea. So let’s add the styling for it with some minimal sizes and remove the text:

<div >
  <input type="checkbox"  name="toggleSwitch"  />
  <label  for="toggleSwitch">
    Toggle Me!
  </label>
</div>

With respect to responsiveness, we should be changing the complete size, so let’s use the CSS scale function. Here we’ve covered all the Bootstrap-based responsive widths of devices.

<div >
  <input type="checkbox"  name="toggleSwitch"  />
  <label  for="toggleSwitch">
    <span ></span>
    <span ></span>
  </label>
</div>

You can test these changes out by adding the small-switch class to the parent

element in ToggleSwitch.js:

import React, { Component } from "react";

class ToggleSwitch extends Component {
  render() {
    return (
      <div className="toggle-switch">
        <input
          type="checkbox"
          className="toggle-switch-checkbox"
          name="toggleSwitch"
          
        />
        <label className="toggle-switch-label" htmlFor="toggleSwitch">
          <span className="toggle-switch-inner" />
          <span className="toggle-switch-switch" />
        </label>
      </div>
    );
  }
}

export default ToggleSwitch;

Head back to the dev server and test your changes. If you’d like to check what you have against the finished SCSS file,?you can find that here.

Step 6 – Theming in SCSS

Since we can use variables in SCSS, it is easier to add support for multiple color themes. You can read more about this in “Sass Theming: The Never Ending Story”. We’ll use some color themes here and change all the raw colors to variables. The first three lines are a configurable set of colors, which helps us theme our little control:

create-react-app toggleswitch

And that’s it with the styling. Now let’s add some interactivity.

Step 7 – Interactions and JavaScript

Please note that the following section only contains demo code to explain the concepts. You should not be updating your actual?ToggleSwitch?component in this section.

Our basic component will be a dumb component (or presentation component) whose state will be controlled by a parent component or container, such as a?form. What do we mean by controlled? Well, let’s look at an uncontrolled version first:

mkdir src/ToggleSwitch

When users interact with the above checkbox input, it will toggle between a checked and unchecked state of its own accord without us having to write any JavaScript. HTML input elements can manage their own internal state by updating the DOM directly.

However, in React, it’s recommended we use?controlled components, as shown in the following example:

touch ToggleSwitch.js ToggleSwitch.scss

Here, React is controlling the state of the checkbox input. All interactions with this input have to go through the virtual DOM. If you try to interact with the component as it is, nothing will happen, as we haven’t defined any JavaScript code that can change the value of the?checked?prop we’re passing in.

To fix this, we can pass in an?onChange?prop — a function to be called whenever the checkbox is clicked:

import React from 'react';
import ToggleSwitch from './ToggleSwitch/ToggleSwitch'

function App() {
  return (
    <ToggleSwitch />
  );
}

export default App;

Now, the checkbox input is interactive. Users can toggle the component “on” and “off” just like before. The only difference here is that the state is controlled by React, as opposed to the earlier uncontrolled version. This allows us to easily access the state of our component at any given time via JavaScript. We can also easily define the initial value when declaring the component.

Now, let’s look at how we can use this in the?ToggleSwitch?component. Below is a simplified class-based example:

<input type="checkbox" name="name"  />

Now let’s convert the class-based component into a functional component using hooks:

<div >
  <input type="checkbox"  name="toggleSwitch"  />
  <label  for="toggleSwitch">
    Toggle Me!
  </label>
</div>

As you can see, we drastically reduced the number of lines using functional components and the hooks creation method.

If React Hooks are new to you, “React Hooks: How to Get Started & Build Your Own”.

Step 8 – Finalizing the ToggleSwitch Component

Now, let’s get back to our?ToggleSwitch?component. We’ll need the following props:

id?(required): This is the ID that will be passed to the checkbox input control. Without it, the component won’t render.
checked?(required): This will hold the current state, which will be a boolean value.
onChange?(required): This function will be called when the input’s?onChange?event handler is triggered.
name?(optional): This will be the label text of the checkbox input, but we will generally not use it.
small?(optional): This boolean value renders the Toggle Switch in a small mode without rendering the text.
optionLabels?(optional): If you aren’t using the?small?version of the control, you might need to pass this to the Toggle Switch as an array of two values, which signify the text for True and False. An example would be?Text={[“Yes”, “No”]}.
disabled?(optional): This will be directly passed to the?.

When the?small?version is not used, the following?optionLabels?text will be used as default:

create-react-app toggleswitch

Since most of the props have to be set by the user, and we can’t use arbitrary values, it’s always better to stop rendering if the required props aren’t passed in. This can be done using a simple JavaScript?if?statement or a ternary operator using?? :?or a short-circuited?&&:

mkdir src/ToggleSwitch

As our app grows, we can catch many bugs by type-checking. React has some built-in type-checking abilities. To run type checking on the props for a component, you can assign the special?propTypes?property. We can enforce the above list of props using React’s?PropType?library, a separate library that exports a range of validators that can be used to ensure the data you receive is valid.

You can install it like so:

touch ToggleSwitch.js ToggleSwitch.scss

Then, import the PropTypes library using:

import React from 'react';
import ToggleSwitch from './ToggleSwitch/ToggleSwitch'

function App() {
  return (
    <ToggleSwitch />
  );
}

export default App;

We’ll define the PropTypes in the following way:

<input type="checkbox" name="name"  />

By way of explanation:

PropTypes.string.isRequired: This is a string value, and it’s required and mandatory.
PropTypes.string: This is a string value, but it isn’t mandatory.
PropTypes.func: This prop takes in a function as a value, but it isn’t mandatory.
PropTypes.bool: This is a boolean value, but it isn’t mandatory.
PropTypes.array: This is an array value, but it isn’t mandatory.

Now, we can carry on with the?ToggleSwitch?component. Replace the contents of?src/ToggleSwitch/ToggleSwitch.js?with the following:

<div >
  <input type="checkbox"  name="toggleSwitch"  />
  <label  for="toggleSwitch">
    Toggle Me!
  </label>
</div>

Finally, to test the component, update the App.js?with the below code:

create-react-app toggleswitch

Now, when you head to?http://localhost:3000/,?you should see the working toggle.

Step 9 – Making the Component Keyboard Accessible

The final step is to make our component keyboard accessible. To do this, first, alter the label like below:

mkdir src/ToggleSwitch

As you can see, we’ve added a?tabIndex?property, which we’re setting to?1?(focusable) or?-1?(not focusable), depending on whether the component is currently disabled.

We’ve also declared a?handleKeyPress?function to deal with it receiving keyboard input:

touch ToggleSwitch.js ToggleSwitch.scss

This checks if the key pressed is the space bar. If so, it prevents the browser’s default action (scroll the page in this case) and toggles the component’s state.

And that’s essentially all you need. The component is now keyboard accessible.

However, there’s a slight problem. If you click the?ToggleSwitch?component, you will get an outline of the entire component, which is probably not desired. To combat this, we can alter things slightly to make sure it receives an outline when it’s focused on the keyboard, but not when it’s clicked:

import React from 'react';
import ToggleSwitch from './ToggleSwitch/ToggleSwitch'

function App() {
  return (
    <ToggleSwitch />
  );
}

export default App;

Here, we’ve added a?tabIndex?property to both inner??elements to ensure they can’t receive focus.

Then, update the ToggleSwitch.scss file with the below code to apply a style to the ToggleSwitch’s inner element when it’s focused on the keyboard but not when it’s clicked.

<input type="checkbox" name="name"  />

You can read more about this technique?here. It’s slightly hacky and should be dropped in favor of?using :focus-visible, as soon as that gains wide enough browser support.

When you run the application, you should be able to toggle the component using the space bar.

A More Complete Example

To finish off, I’d like to demonstrate a more complete example of using the?ToggleSwitch?component in the following CodeSandbox.

This demo uses multiple?ToggleSwitch?components on the same page. The state of the last three toggles depends on the state of the first. That is, you need to accept marketing emails before you can refine your choice of which ones to receive.

Summary

In this article, I’ve shown how to create a reusable, iOS-inspired React toggle component using React. We looked at styling the component with SCSS, making it a controlled component, customizing it by passing it props, and making it keyboard accessible.

You can find the complete code for the React toggle component on our?GitHub repo.

FAQs on How to Create a Toggle Switch in React as a Reusable Component

How Can I Customize the Appearance of My React Toggle Switch?

Customizing the appearance of your React toggle switch is quite straightforward. You can modify the CSS properties to suit your design needs. For instance, you can change the switch’s background color, border color, size, and shape. You can also add animations or transitions for a more interactive user experience. Remember to keep your changes consistent with your overall application design for a seamless user experience.

Can I Use the Switch Button React Component with Functional Components?

Yes, you can use the React toggle switch with functional components. The process is similar to using it with class components. You just need to import and use the switch component in your functional component. You can also use hooks like useState to manage the state of the switch.

How Can I Make My Switch Button React Component Accessible?

Accessibility is a crucial aspect of web development. To make your React toggle switch accessible, you can use ARIA (Accessible Rich Internet Applications) attributes. For instance, you can use the “aria-checked” attribute to indicate the state of the switch. You can also add keyboard support to allow users to toggle the switch using the keyboard.

How Can I Test My React Switch Component?

Testing is an essential part of the development process. You can use testing libraries like Jest and React Testing Library to test your react switch component. You can write tests to check if the switch toggles and renders correctly when clicked and handles props correctly.

Can I Use the React Toggle Switch with Redux?

Yes, you can use the React toggle switch with Redux. You can manage the state of the switch using Redux actions and reducers. This can be particularly useful if the state of the switch needs to be shared across multiple components or if it affects the global state of your application.

How Can I Add a Label to My React Toggle Switch?

Adding a label to your React toggle switch can improve its usability. You can add a label by wrapping the react switch component in a “l(fā)abel” element. You can also use the “htmlFor” attribute to associate the label with the switch.

How Can I Handle Errors in My React Toggle Switch Component?

Error handling is an important part of any component. In your React toggle switch component, you can use try-catch blocks to handle errors. You can also use error boundaries, a React feature that catches and handles errors in components.

Can I Use the React Toggle Switch in a Form?

Yes, you can use the React toggle switch in a form. You can handle the state of the switch in the form’s state. You can also handle the form submission and use the state of the switch to perform certain actions.

How Can I Animate My React Toggle Switch?

Animating your React toggle switch can enhance the user experience. You can use CSS transitions or animations to animate the switch, or you can use libraries like React Spring for more complex animations.

Can I Use the React Toggle Switch with TypeScript?

Yes, you can use the React toggle switch with TypeScript. You just need to define the props’ types and the switch’s state. This can help you catch errors during development and make your code more robust and maintainable.

How Can I Optimize the Performance of Switch Toggles?

You can optimize the performance of your React toggle switch by using React’s memo function to prevent unnecessary re-renders.

How Can I Handle State Management for Multiple Toggle Switches in a Single Form?

You can manage the state of multiple toggle switches in a single form by using an object to store each switch’s state. This allows you to easily update and access the state of each switch, making your form handling more efficient.

The above is the detailed content of Create a Toggle Switch in React as a Reusable Component. For more information, please follow other related articles on the PHP Chinese website!

Statement of this Website

The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

Hot AI Tools

Undress AI Tool

Undress images for free

Undresser.AI Undress

AI-powered app for creating realistic nude photos

AI Clothes Remover

Online AI tool for removing clothes from photos.

Clothoff.io

AI clothes remover

Video Face Swap

Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Oguri Cap Build Guide | A Pretty Derby Musume

3 weeks ago By Jack chen

Agnes Tachyon Build Guide | A Pretty Derby Musume

3 weeks ago By Jack chen

Grass Wonder Build Guide | Uma Musume Pretty Derby

2 weeks ago By Jack chen

Own a Fish Pond codes June 2025

1 months ago By Jack chen

How to Fix KB5060829 Not Installing & Other Reported Bugs

3 weeks ago By DDD

Hot Tools

Notepad++7.3.1

Easy-to-use and free code editor

SublimeText3 Chinese version

Chinese version, very easy to use

Zend Studio 13.0.1

Powerful PHP integrated development environment

Dreamweaver CS6

Visual web development tools

SublimeText3 Mac version

God-level code editing software (SublimeText3)

Hot Topics

Java Tutorial

1794

CakePHP Tutorial

1739

Laravel Tutorial

1590

PHP Tutorial

1468

nyt mini crossword answers

267

587

Related knowledge

Why should you place tags at the bottom of the ? Jul 02, 2025 am 01:22 AM

PlacingtagsatthebottomofablogpostorwebpageservespracticalpurposesforSEO,userexperience,anddesign.1.IthelpswithSEObyallowingsearchenginestoaccesskeyword-relevanttagswithoutclutteringthemaincontent.2.Itimprovesuserexperiencebykeepingthefocusonthearticl

How to work with dates and times in js? Jul 01, 2025 am 01:27 AM

The following points should be noted when processing dates and time in JavaScript: 1. There are many ways to create Date objects. It is recommended to use ISO format strings to ensure compatibility; 2. Get and set time information can be obtained and set methods, and note that the month starts from 0; 3. Manually formatting dates requires strings, and third-party libraries can also be used; 4. It is recommended to use libraries that support time zones, such as Luxon. Mastering these key points can effectively avoid common mistakes.

What is event bubbling and capturing in the DOM? Jul 02, 2025 am 01:19 AM

Event capture and bubble are two stages of event propagation in DOM. Capture is from the top layer to the target element, and bubble is from the target element to the top layer. 1. Event capture is implemented by setting the useCapture parameter of addEventListener to true; 2. Event bubble is the default behavior, useCapture is set to false or omitted; 3. Event propagation can be used to prevent event propagation; 4. Event bubbling supports event delegation to improve dynamic content processing efficiency; 5. Capture can be used to intercept events in advance, such as logging or error processing. Understanding these two phases helps to accurately control the timing and how JavaScript responds to user operations.

How to make an HTTP request in Node.js? Jul 13, 2025 am 02:18 AM

There are three common ways to initiate HTTP requests in Node.js: use built-in modules, axios, and node-fetch. 1. Use the built-in http/https module without dependencies, which is suitable for basic scenarios, but requires manual processing of data stitching and error monitoring, such as using https.get() to obtain data or send POST requests through .write(); 2.axios is a third-party library based on Promise. It has concise syntax and powerful functions, supports async/await, automatic JSON conversion, interceptor, etc. It is recommended to simplify asynchronous request operations; 3.node-fetch provides a style similar to browser fetch, based on Promise and simple syntax

A definitive JS roundup on JavaScript modules: ES Modules vs CommonJS Jul 02, 2025 am 01:28 AM

The main difference between ES module and CommonJS is the loading method and usage scenario. 1.CommonJS is synchronously loaded, suitable for Node.js server-side environment; 2.ES module is asynchronously loaded, suitable for network environments such as browsers; 3. Syntax, ES module uses import/export and must be located in the top-level scope, while CommonJS uses require/module.exports, which can be called dynamically at runtime; 4.CommonJS is widely used in old versions of Node.js and libraries that rely on it such as Express, while ES modules are suitable for modern front-end frameworks and Node.jsv14; 5. Although it can be mixed, it can easily cause problems.

How does garbage collection work in JavaScript? Jul 04, 2025 am 12:42 AM

JavaScript's garbage collection mechanism automatically manages memory through a tag-clearing algorithm to reduce the risk of memory leakage. The engine traverses and marks the active object from the root object, and unmarked is treated as garbage and cleared. For example, when the object is no longer referenced (such as setting the variable to null), it will be released in the next round of recycling. Common causes of memory leaks include: ① Uncleared timers or event listeners; ② References to external variables in closures; ③ Global variables continue to hold a large amount of data. The V8 engine optimizes recycling efficiency through strategies such as generational recycling, incremental marking, parallel/concurrent recycling, and reduces the main thread blocking time. During development, unnecessary global references should be avoided and object associations should be promptly decorated to improve performance and stability.

var vs let vs const: a quick JS roundup explainer Jul 02, 2025 am 01:18 AM

The difference between var, let and const is scope, promotion and repeated declarations. 1.var is the function scope, with variable promotion, allowing repeated declarations; 2.let is the block-level scope, with temporary dead zones, and repeated declarations are not allowed; 3.const is also the block-level scope, and must be assigned immediately, and cannot be reassigned, but the internal value of the reference type can be modified. Use const first, use let when changing variables, and avoid using var.

Why is DOM manipulation slow and how can it be optimized? Jul 01, 2025 am 01:28 AM

The main reasons for slow operation of DOM are the high cost of rearrangement and redrawing and low access efficiency. Optimization methods include: 1. Reduce the number of accesses and cache read values; 2. Batch read and write operations; 3. Merge and modify, use document fragments or hidden elements; 4. Avoid layout jitter and centrally handle read and write; 5. Use framework or requestAnimationFrame asynchronous update.

See all articles

国产av日韩一区二区三区精品,成人性爱视频在线观看,国产,欧美,日韩,一区,www.成色av久久成人,2222eeee成人天堂

Create a Toggle Switch in React as a Reusable Component