如何向 ReactJS 组件添加多个类

我使用ES6模板文字。例如：

const error = this.state.valid ? '' : 'error'
const classes = `form-control round-lg ${error}`

然后只需渲染它：

<input className={classes} />

单行版本：

<input className={`form-control round-lg ${this.state.valid ? '' : 'error'}`} />

当决定(不(使用的类需要相当多的逻辑时，我会使用类名。一个过于简单的例子：

...
    var liClasses = classNames({
      'main-class': true,
      'activeClass': self.state.focused === index
    });
    return (<li className={liClasses}>{data.name}</li>);
...

也就是说，如果您不想包含依赖项，那么下面有更好的答案。

只需使用 JavaScript。

<li className={[activeClass, data.klass, "main-class"].join(' ')} />

如果要在对象中添加基于类的键和值，可以使用以下内容：

function classNames(classes) {
  return Object.entries(classes)
    .filter(([key, value]) => value)
    .map(([key, value]) => key)
    .join(' ');
}
const classes = {
  'maybeClass': true,
  'otherClass': true,
  'probablyNotClass': false,
};
const myClassNames = classNames(classes);
// Output: "maybeClass otherClass"
<li className={myClassNames} />

甚至更简单：

const isEnabled = true;
const isChecked = false;
<li className={[isEnabled && 'enabled', isChecked && 'checked']
  .filter(e => !!e)
  .join(' ')
} />
// Output:
// <li className={'enabled'} />

Concat

无需花哨，我正在使用CSS模块，这很容易

import style from '/css/style.css';
<div className={style.style1+ ' ' + style.style2} />

这将导致：

<div class="src-client-css-pages-style1-selectionItem src-client-css-pages-style2">

换句话说，两种风格

条件

相同的想法与 if 一起使用

const class1 = doIHaveSomething ? style.style1 : 'backupClass';
<div className={class1 + ' ' + style.style2} />

ES6

在过去的一年左右的时间里，我一直在使用模板文字，所以我觉得它值得一提，我发现它非常富有表现力且易于阅读：

`${class1} anotherClass ${class1}`

这可以通过 ES6 模板文字来实现：

<input className={`base-input-class ${class1} ${class2}`}>

(为清楚起见，已编辑(

您可以创建具有多个类名的元素，如下所示：

<li className="class1 class2 class3">foo</li>

当然，您可以使用包含类名的字符串并操作此字符串来更新元素的类名。

var myClassNammes = 'class1 class2 class3';
...
<li className={myClassNames}>foo</li>

这是使用 ES6 执行此操作的方法：

className = {`
      text-right
      ${itemId === activeItemId ? 'active' : ''}
      ${anotherProperty === true ? 'class1' : 'class2'}
`}

您可以列出多个类和条件，也可以包括静态类。无需添加其他库。

祝你好运;)

一般来说，人们确实喜欢

<div className={  `head ${style.class1} ${Style.class2}`  }><div>

或

<div className={  'head ' + style.class1 + ' ' + Style.class2 }><div>

或

<div className={  ['head', style.class1 , Style.class2].join(' ')  }><div>

但是您可以选择创建一个函数来完成这项工作

function joinAll(...classes) {
  return classes.join(" ")
}

然后这样称呼它：-

<div className={joinAll('head', style.class1 , style.class2)}><div>

香草 JS

无需外部库 - 只需使用 ES6 模板字符串：

<i className={`${styles['foo-bar-baz']} fa fa-user fa-2x`}/>

我们不需要使用外部包来添加多个类。

我个人使用

<li className={`li active`}>Stacy</li>

或

<li className={`li ${this.state.isActive ? 'active' : ''}`}>Stacy<li>

或

<li className={'li ' + (this.state.isActive ? 'active' : '') }>Stacy<li>

第二个和第三个，以防您需要有条件地添加或删除类。

使用 CSS 模块(或 Sass 模块(，您也可以将样式隔离到特定组件。

允许你编写传统的，可移植的CSS，副作用最小：选择器名称冲突或影响其他组件样式的担忧已经一去不复返了。

import * as styles from "./whatever.module.css"  // css version
import * as styles from "./whatever.module.scss" // sass version
<div className={`${styles.class1} ${styles.class2}`}>
   INSERT YOUR CODE HERE
</div>

参考文献1Ref2

也许类名可以帮助你。

var classNames = require('classnames');
classNames('foo', {'xx-test': true, bar: false}, {'ox-test': false}); // => 'foo xx-test'

可以用 https://www.npmjs.com/package/clsx 来完成：

https://www.npmjs.com/package/clsx

首先安装它：

npm install --save clsx

然后将其导入到组件文件中：

import clsx from  'clsx';

然后在组件中使用导入的函数：

<div className={ clsx(classes.class1, classes.class2)}>

您可以执行以下操作：

<li key={index} className={`${activeClass} ${data.class} main-class`}></li>

一个简短而简单的解决方案，希望这有帮助。

只需添加，我们可以过滤掉空字符串。

className={[
    'read-more-box',
    this.props.className,
    this.state.isExpanded ? 'open' : 'close',
].filter(x => !!x).join(' ')}

您可以像这样创建一个具有多个类名的元素，我尝试了这两种方式，它工作正常...

如果您导入任何 css，那么您可以按照以下方式操作：方式1：

import React, { Component, PropTypes } from 'react';
import csjs from 'csjs';
import styles from './styles';
import insertCss from 'insert-css';
import classNames from 'classnames';
insertCss(csjs.getCss(styles));
export default class Foo extends Component {
  render() {
    return (
      <div className={[styles.class1, styles.class2].join(' ')}>
        { 'text' }
      </div>
    );
  }
}

方式2：

import React, { Component, PropTypes } from 'react';
import csjs from 'csjs';
import styles from './styles';
import insertCss from 'insert-css';
import classNames from 'classnames';
insertCss(csjs.getCss(styles));
export default class Foo extends Component {
  render() {
    return (
      <div className={styles.class1 + ' ' + styles.class2}>
        { 'text' }
      </div>
    );
  }
}

**

如果将 css 应用为内部：

const myStyle = {
  color: "#fff"
};
// React Element using Jsx
const myReactElement = (
  <h1 style={myStyle} className="myClassName myClassName1">
    Hello World!
  </h1>
);
ReactDOM.render(myReactElement, document.getElementById("app"));

.myClassName {
  background-color: #333;
  padding: 10px;
}
.myClassName1{
  border: 2px solid #000;
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/react/16.4.0/umd/react.production.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.4.0/umd/react-dom.production.min.js"></script>
<div id="app">
  
</div>

似乎对我有用

<Link className={[classes.button, classes.buttonFirst]}>

用于添加更多类

... className={`${classes.hello} ${classes.hello1}`...

这是一个迟到的答案，但我希望这会对某人有所帮助。

假设您在 css 文件中定义了以下类 'primary'， 'font-i'， 'font-xl'

• 第一步是导入CSS文件。
• 然后

<h3 class = {` ${'primary'} ${'font-i'} font-xl`}> HELLO WORLD </h3>

会做的伎俩！

更多信息： https://www.youtube.com/watch?v=j5P9FHiBVNo&list=PLC3y8-rFHvwgg3vaYJgHGnModB54rxOk3&index=20

创建这样的函数

function cssClass(...c) {
  return c.join(" ")
}

在需要时调用它。

<div className={cssClass("head",Style.element,"black")}><div>

派对迟到了，但为什么要使用第三方来解决这么简单的问题？

你可以按照戴维斯提到的@Huw去做 - 最好的方法

1. <i className={`${styles['foo-bar-baz']} fa fa-user fa-2x`}/>
2. <i className={[styles['foo-bar-baz'], 'fa fa-user', 'fa-2x'].join(' ')}

两者都很好。但是，对于大型应用而言，编写可能会变得复杂。为了使它成为最佳选择，我在上面做了同样的事情，但把它放在一个辅助类中

使用我的以下辅助函数，允许我将逻辑分开以供将来编辑，并且还为我提供了多种添加类的方法

classNames(styles['foo-bar-baz], 'fa fa-user', 'fa-2x')

或

classNames([styles['foo-bar-baz], 'fa fa-user', 'fa-2x'])

这是我下面的助手功能。我把它放在一个助手中.js在那里我保留了我所有的常用方法。作为一个如此简单的功能，我避免使用第三方来保持控制

export function classNames (classes) {
    if(classes && classes.constructor === Array) {
        return classes.join(' ')
    } else if(arguments[0] !== undefined) {
        return [...arguments].join(' ')
    }
    return ''
}

您可以使用数组，然后使用空格连接它们。

<li key={index} className={[activeClass, data.class, "main-class"].join(' ')}></li>

这将导致：

<li key={index} class="activeClass data.class main-class"></li>

clsx 让这变得简单！

"clsx函数可以接受任意数量的参数，每个参数都可以是对象、数组、布尔值或字符串。

-- CLSX Docs on npmjs.com

导入它：

import clsx from 'clsx'

使用它：

<li key={index} className={clsx(activeClass, data.class, "main-class")}></li>

当我有许多不同的类时，我发现以下内容很有用。

筛选器删除任何null值，联接将所有剩余值放入空格分隔的字符串中。

const buttonClasses = [
    "Button", 
    disabled ? "disabled" : null,
    active ? "active" : null
].filter((class) => class).join(" ")
<button className={buttonClasses} onClick={onClick} disabled={disabled ? disabled : false}>

我使用了这种语法

    <div
      className={[
        "d-inline-flex justify-content-center align-items-center ",
        withWrapper && `ft-icon-wrapper ft-icon-wrapper-${size}`,
        wrapperClass,
      ].join(" ")}
    >
      <img
        className={`ft-icon ft-icon-${size} ${iconClass}`}
        alt={id}
        src={icon}
      />
    </div>

对于这个问题，我使用这个util函数：

export function cn(...args: string[]): string{
    return args.filter(Boolean).join(' ');
}

并以这种方式应用它：

<div className={cn(inter.className, styles.planColumns)}>

使用 facebook 的 TodoTextInput.js示例

render() {
    return (
      <input className={
        classnames({
          edit: this.props.editing,
          'new-todo': this.props.newTodo
        })}
        type="text"
        placeholder={this.props.placeholder}
        autoFocus="true"
        value={this.state.text}
        onBlur={this.handleBlur}
        onChange={this.handleChange}
        onKeyDown={this.handleSubmit} />
    )
  } 

用普通的 JS 代码替换类名将如下所示：

render() {
    return (
      <input
        className={`
          ${this.props.editing ? 'edit' : ''} ${this.props.newTodo ? 'new-todo' : ''}
        `}
        type="text"
        placeholder={this.props.placeholder}
        autoFocus="true"
        value={this.state.text}
        onBlur={this.handleBlur}
        onChange={this.handleChange}
        onKeyDown={this.handleSubmit} />
    )
  }

如果您不想导入另一个模块，此函数的工作方式类似于classNames模块。

function classNames(rules) {
    var classes = ''
    Object.keys(rules).forEach(item => {    
        if (rules[item])
            classes += (classes.length ? ' ' : '') + item
    })
    return classes
} 

你可以像这样使用它：

render() {
    var classes = classNames({
        'storeInfoDiv': true,  
        'hover': this.state.isHovered == this.props.store.store_id
    })   
    return (
        <SomeComponent style={classes} />
    )
}

使用 https://www.npmjs.com/package/classnames

从"类名"导入类名;

1. 可以使用多个类，使用逗号分隔：

   <li className={classNames(classes.tableCellLabel, classes.tableCell)}>Total</li>
   

2. 可以使用多个类，使用逗号与条件分隔：

   <li className={classNames(classes.buttonArea, !nodes.length && classes.buttonAreaHidden)}>Hello World</li> 
   

使用数组作为类名的道具也可以工作，但会发出警告，例如

className={[classes.tableCellLabel, classes.tableCell]}

你可以使用 react-directive，它支持所有 react 元素，甚至支持 dirIf、dirShow、dirFor 和扩展 className 等指令

您可以执行以下操作：

import { useState } from 'react'
import directive from 'react-directive';
function Component() {
  const [isActive, setIsActive] = useState(true);
  const [isDisabled, setIsDisabled] = useState(false);
  return <directive.div className={{isActive, isDisabled}}>Contents</directive.div>;
}
// Renders <div class="isActive">Contents</div>

您甚至可以提供一些依赖项，这些依赖项将在发生任何更改时重新计算类名。我是图书馆的作者。