在 JavaScript 中加载 CSS 文件，常用的方法包括：

1. **使用 JavaScript 创建 `<link>` 标签并添加到 `<head>` 中**

```javascript
var head = document.head;
var link = document.createElement('link');

link.type = 'text/css';
link.rel = 'stylesheet';
link.href = 'path/to/your/cssfile.css';

head.appendChild(link);
```

2. **使用 jQuery（如果你的项目中包含了 jQuery）**

```javascript
$('head').append('<link rel="stylesheet" type="text/css" href="path/to/your/cssfile.css">');
```

3. **使用 `import` 语句在 JavaScript 模块中**

如果你在使用支持模块的现代 JavaScript 中，可以使用 `import` 语法。

```javascript
import './path/to/your/cssfile.css';
```

请注意，这通常需要构建工具（如 Webpack 或 Parcel）来处理 CSS 文件的导入。

4. **使用 `fetch` API 动态获取 CSS 内容并插入**

```javascript
fetch('path/to/your/cssfile.css')
    .then(response => response.text())
    .then(css => {
        var style = document.createElement('style');
        style.textContent = css;
        document.head.appendChild(style);
    });
```

以上就是一些在 JavaScript 中加载 CSS 文件的方法。选择哪种方法取决于你的具体需求和项目的构建环境。

这是“老派”的做法，希望它适用于所有浏览器。理论上，您会`setAttribute`不幸地使用 IE6 并不始终支持它。

    var cssId = 'myCss';  // you could encode the css path itself to generate id..
    if (!document.getElementById(cssId))
    {
        var head  = document.getElementsByTagName('head')[0];
        var link  = document.createElement('link');
        link.id   = cssId;
        link.rel  = 'stylesheet';
        link.type = 'text/css';
        link.href = 'http://website.example/css/stylesheet.css';
        link.media = 'all';
        head.appendChild(link);
    }
    

此示例检查 CSS 是否已添加，因此仅添加一次。

将该代码放入 JavaScript 文件中，让最终用户只需包含 JavaScript，并确保 CSS 路径是绝对路径，以便从服务器加载它。

香草JS
====

`head`下面是一个使用纯 JavaScript根据 URL 的文件名部分将 CSS 链接注入到元素中的示例：

    <script type="text/javascript">
    var file = location.pathname.split( "/" ).pop();
    
    var link = document.createElement( "link" );
    link.href = file.substr( 0, file.lastIndexOf( "." ) ) + ".css";
    link.type = "text/css";
    link.rel = "stylesheet";
    link.media = "screen,print";
    
    document.getElementsByTagName( "head" )[0].appendChild( link );
    </script>
    

在结束标记之前插入代码`head`，CSS 将在页面呈现之前加载。使用外部 JavaScript ( ) 文件将导致出现无样式内容 ( [FOUC](http://en.wikipedia.org/wiki/Flash_of_unstyled_content)`.js` )的 Flash 。[](http://en.wikipedia.org/wiki/Flash_of_unstyled_content)

如果你使用jquery：

    $('head').append('<link rel="stylesheet" type="text/css" href="style.css">');

我想这个脚本会做这样的事情：

    <script type="text/javascript" src="/js/styles.js"></script>
    

该JS文件包含以下语句：

    if (!document.getElementById) document.write('<link rel="stylesheet" type="text/css" href="/css/versions4.css">');
    

如果 javascript 和 css 要引用您的网站，则它们的地址必须是绝对的。

[这篇“用分支技术对 CSS 黑客说不”](http://www.tjkdesign.com/articles/branching.asp)一文讨论了许多 CSS 导入技术。

但是[“使用 JavaScript 动态添加 Portlet CSS 样式表”](http://cse-mjmcl.cse.bris.ac.uk/blog/2005/08/18/1124396539593.html)一文还提到了 CreateStyleSheet 的可能性（IE 的专有方法）：

    <script type="text/javascript">
    //<![CDATA[
    if(document.createStyleSheet) {
      document.createStyleSheet('http://server/stylesheet.css');
    }
    else {
      var styles = "@import url(' http://server/stylesheet.css ');";
      var newSS=document.createElement('link');
      newSS.rel='stylesheet';
      newSS.href='data:text/css,'+escape(styles);
      document.getElementsByTagName("head")[0].appendChild(newSS);
    }
    //]]>

[Element.insertAdjacentHTML](https://developer.mozilla.org/en-US/docs/Web/API/Element/insertAdjacentHTML)具有很好的浏览器支持，并且可以在一行中添加样式表。

    document.getElementsByTagName('head')[0].insertAdjacentHTML(
        'beforeend',
        '<link rel="stylesheet" href="path/to/style.css" />');

如果您想知道（或等待）样式本身加载，则可以执行以下操作：

    // this will work in IE 10, 11 and Safari/Chrome/Firefox/Edge
    // add ES6 poly-fill for the Promise, if needed (or rewrite to use a callback)
    
    let fetchStyle = function(url) {
      return new Promise((resolve, reject) => {
        let link = document.createElement('link');
        link.type = 'text/css';
        link.rel = 'stylesheet';
        link.onload = () => resolve();
        link.onerror = () => reject();
        link.href = url;
    
        let headScript = document.querySelector('script');
        headScript.parentNode.insertBefore(link, headScript);
      });
    };
    

用法：

    fetchStyle(url)
     .then(
       () => console.log("style loaded succesfully"),
       () => console.error("style could not be loaded"),
    );

如何使用 javascript 加载 css 文件？

在CSS中，`display: none`用于隐藏元素，但它不会阻止浏览器下载背景图像。例如，如果你在一个`div`元素上使用`display: none`样式，并且这个`div`有一个CSS背景图像，那么浏览器仍然会下载这个图像，尽管它在视觉上是不可见的。

但是，如果我们谈论的是`<img>`标签中的图像，使用`display: none`会有所不同。对于`<img>`标签，大多数现代浏览器会优化加载过程，如果图像使用`display: none`进行了隐藏，浏览器可能会推迟图像的加载，或者在图像不会对用户可见的情况下完全不加载它。

这种行为并不是在所有浏览器中都是一样的，也可能随着浏览器的更新而变化。一般来说，如果确实希望防止图像加载，最好的做法是不要在HTML代码中包含该图像。如果需要在用户交互之后加载图像，可以采取动态插入图像标签的方法或使用JavaScript按需加载。

要举一个例子，假设有一个网页，其中包含以下HTML和CSS代码：

```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Image Loading Example</title>
<style>
.hidden {
  display: none;
}
</style>
</head>
<body>

<img src="example.jpg" alt="Example Image" class="hidden">

</body>
</html>
```

在上述代码中，即使`.hidden`类应用了`display: none`，某些浏览器可能仍然会下载`example.jpg`图像。但如果你打算确保图像不被预加载，你可以通过JavaScript动态设置图像的`src`属性来控制加载：

```javascript
document.addEventListener('DOMContentLoaded', function() {
  // 假设用户执行了某个操作，例如点击按钮
  document.getElementById('loadImageButton').addEventListener('click', function() {
    var img = document.getElementById('exampleImage');
    img.src = 'example.jpg';
    img.classList.remove('hidden');
  });
});
```

在这个例子中，只有在用户点击了一个按钮之后，图像才会被加载，因此在页面初始加载时，`example.jpg`并不会被下载。

浏览器变得越来越智能。今天，如果您的浏览器（取决于版本）确定图像没有用，可能会跳过图像加载。

图像具有`display:none`样式，但其大小可以由脚本读取。如果父级隐藏，Chrome v68.0 不会加载图像。

您可以在那里查看： http: [//jsfiddle.net/tnk3j08s/](http://jsfiddle.net/tnk3j08s/)

您还可以通过查看浏览器开发人员工具的“网络”选项卡来检查它。

请注意，如果浏览器位于小型 CPU 计算机上，则不必渲染图像（并布局页面）将使整个渲染操作更快，但我怀疑这在今天是否真正有意义。

如果您想阻止图像加载，您可以简单地不将 IMG 元素添加到文档中（或将 IMG`src`属性设置为`"data:"`或`"about:blank"`）。

如果图像位于第一个屏幕上且未延迟加载，“display: none”将不起作用。图像将加载但不显示。

如果您在 CSS 中将图像设置为 div 的背景图像，则当该 div 设置为“display: none”时，图像将不会加载。当 CSS 被禁用时，它仍然不会加载，因为 CSS 被禁用了。

答案并不像简单的是或否那么简单。看看我最近做的测试结果：

*   在 Chrome 中：已加载所有 8 个屏幕截图-\* 图像 (img 1)
*   在 Firefox 中：仅加载当前显示的 1 个屏幕截图-\* 图像 (img 2)

因此，在进一步挖掘之后，我发现了[这个](http://web.archive.org/web/20130830082659/http://www.justinmarsan.com/blog/researches/hidden-elements-and-http-requests.html)，它解释了每个浏览器如何处理基于 css display: none; 加载 img 资源。

博客文章摘录：

> *   Chrome 和 Safari (WebKit)：  
>     WebKit 每次都会下载文件，除非通过不匹配的媒体查询应用背景。
> *   Firefox：  
>     如果样式被隐藏，Firefox将不会下载带有背景图像的图像，但它们仍然会从img标签下载资源。
> *   Opera：  
>     与 Firefox 一样，Opera 不会加载无用的背景图像。
> *   Internet Explorer：  
>     IE，像WebKit一样，会下载背景图像，即使它们有display：none； IE6 中出现了一些奇怪的情况：具有背景图像和显示的元素：不会下载内联设置的元素...但如果这些样式未内联应用，它们就会被下载。

![Chrome-全部 8 张屏幕截图-* 图像已加载](https://i.stack.imgur.com/pzKgS.png)

![Firefox - 仅加载当前显示的 1 个屏幕截图 -* 图像](https://i.stack.imgur.com/ARF9g.png)

HTML5`<picture>`标签将帮助您根据屏幕宽度解析正确的图像源
====================================

显然，浏览器的行为在过去 5 年里没有太大变化，许多人仍然会下载隐藏的图像，即使它们设置了属性`display: none`。

尽管有[媒体查询](https://developer.mozilla.org/en-US/docs/Web/CSS/Media_Queries/Using_media_queries)解决方法，但只有当图像在 CSS 中设置为背景时它才有用。

虽然我认为只有一个 JS 解决方案可以解决这个问题（[延迟加载](https://css-tricks.com/snippets/javascript/lazy-loading-images/)、[图片填充](http://scottjehl.github.io/picturefill/)等），但似乎有一个很好的纯 HTML 解决方案，可以随 HTML5 一起使用。

这就是`<picture>`标签。

[MDN](https://developer.mozilla.org/en/docs/Web/HTML/Element/picture)是这样描述的：

> HTML**元素**是一个容器，用于指定其中包含的**特定`<picture>`**`<source>`多个元素。`<img>`浏览器将根据页面的当前布局（图像将出现的框的约束）和将显示图像的设备（例如普通或 hiDPI 设备）来选择最合适的源。

使用方法如下：

    <picture>
     <source srcset="mdn-logo-wide.png" media="(min-width: 600px)">
     <img src="mdn-logo-narrow.png" alt="MDN">
    </picture>
    

### 背后的逻辑

`img`仅当没有任何媒体规则适用时，浏览器才会加载标记的源。当`<picture>`浏览器不支持该元素时，它将再次回退到显示标签`img`。

通常，您会将最小的图像作为源`<img>`，因此不会为较大的屏幕加载较重的图像。反之亦然，如果适用媒体规则，则`<img>`不会下载源，而是下载相应`<source>`标签的 url 内容。

这里唯一的陷阱是，如果浏览器不支持该元素，它只会加载小图像。另一方面，2017 年我们应该以_移动优先的_方式思考和编码。

在有人退出之前，以下是_当前_浏览器对以下内容的支持`<picture>`：

桌面浏览器
-----

[![桌面浏览器支持](https://i.stack.imgur.com/wk7IN.png)](https://developer.mozilla.org/en/docs/Web/HTML/Element/picture)

移动浏览器
-----

[![移动浏览器支持](https://i.stack.imgur.com/NhzVq.png)](https://i.stack.imgur.com/wk7IN.png)

有关浏览器支持的更多信息，您可以在[我可以使用](http://caniuse.com/#search=picture)上找到。

好处是[html5please](http://html5please.com/#picture)的这句话是用_后备来使用它_。我个人打算听取他们的建议。

[有关该标签的更多信息，您可以在W3C 规范](http://w3c.github.io/html/semantics-embedded-content.html#the-picture-element)中找到。其中有一个免责声明，我认为值得一提的是：

> 该`picture`元素与外观相似的`video`和`audio`元素有些不同。虽然它们都包含元素，但当元素嵌套在元素内时，`source`源元素的属性没有任何意义，并且资源选择算法不同。同样，元素本身不显示任何内容；它只是为其包含的元素提供上下文，使其能够从多个 URL 中进行选择。`src``picture``picture``img`

所以它的意思是，它只是通过为图像提供一些上下文来帮助您提高加载图像时的性能。

你仍然可以使用一些 CSS 魔法来隐藏小型设备上的图像：

    <style>
      picture { display: none; }
    
      @media (min-width: 600px) {
        picture {
          display: block;
        }
      }
    </style>
    
    <picture>
     <source srcset="the-real-image-source" media="(min-width: 600px)">
     <img src="a-1x1-pixel-image-that-will-be-hidden-in-the-css" alt="MDN">
    </picture>
    

因此，浏览器不会_显示_实际图像，而只会下载`1x1`像素图像（如果多次使用，可以缓存该图像）。但请注意，如果`<picture>`浏览器不支持该标签，即使在桌面屏幕上也_不会_显示实际图像（因此您肯定需要在那里进行填充备份）。

2023 年更新：
=========

`display: none`不，但`loading=lazy`确实！
-----------------------------------

即使图像直接或间接被`display: none`属性隐藏，浏览器仍然会下载图像。防止这种情况发生的唯一标准方法是使用[`loading="lazy"`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#loading)：

    <img src="https://cdn.example/image.jpg" loading="lazy">
    

> 推迟加载图像，直到图像达到浏览器定义的距视口的计算距离。目的是避免处理图像所需的网络和存储带宽，直到相当确定需要它为止。这通常会提高大多数典型用例中内容的性能。

所有最新的桌面和移动网络浏览器都[支持它](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img#browser_compatibility)。

在CSS中，`display: none`用于隐藏元素，但它不会阻止浏览器下载背景图像。例如，如果你在一个 `div`元素上使用 `display: none`样式，并且这个 `div`有一个CSS背景图像，那么浏览器仍然会下载这个图像，尽管它在视觉上是不可见的。

但是，如果我们谈论的是 `<img>`标签中的图像，使用 `display: none`会有所不同。对于 `<img>`标签，大多数现代浏览器会优化加载过程，如果图像使用 `display: none`进行了隐藏，浏览器可能会推迟图像的加载，或者在图像不会对用户可见的情况下完全不加载它。

这种行为并不是在所有浏览器中都是一样的，也可能随着浏览器的更新而变化。一般来说，如果确实希望防止图像加载，最好的做法是不要在HTML代码中包含该图像。如果需要在用户交互之后加载图像，可以采取动态插入图像标签的方法或使用JavaScript按需加载。

要举一个例子，假设有一个网页，其中包含以下HTML和CSS代码：

```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Image Loading Example</title>
<style>
.hidden {
  display: none;
}
</style>
</head>
<body>

<img src="https://cdn.portal.levenx.com/levenx-world/3hQQtcQif-8j446Z.jpg" alt="Example Image" class="hidden">

</body>
</html>
```

在上述代码中，即使 `.hidden`类应用了 `display: none`，某些浏览器可能仍然会下载 `example.jpg`图像。但如果你打算确保图像不被预加载，你可以通过JavaScript动态设置图像的 `src`属性来控制加载：

```javascript
document.addEventListener('DOMContentLoaded', function() {
  // 假设用户执行了某个操作，例如点击按钮
  document.getElementById('loadImageButton').addEventListener('click', function() {
    var img = document.getElementById('exampleImage');
    img.src = 'example.jpg';
    img.classList.remove('hidden');
  });
});
```

CSS 的 display:none 是否阻止 image 的加载？

要删除HTML中锚点（链接）的下划线，你通常需要使用CSS。这里有一个简单的例子，展示了如何为网站上的所有链接删除下划线：

```css
a {
  text-decoration: none;
}
```

如果你只想针对特定的链接删除下划线，你可以给那个链接添加一个类，然后指定那个类在CSS中不显示下划线：

```html

<a href="https://www.example.com" class="no-underline">这是一个没有下划线的链接</a>
```

```css
/* CSS */
.no-underline {
  text-decoration: none;
}
```

请记得将CSS代码放到HTML文件的`<head>`部分中的`<style>`标签内，或者放到一个外部的CSS文件中，然后在HTML中通过`<link>`标签引入。

例如，使用`<style>`标签：

```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Remove Link Underline</title>
<style>
  /* 这里是CSS代码 */
  a {
    text-decoration: none;
  }
</style>
</head>
<body>


<a href="https://www.example.com">Visit Example.com</a>

</body>
</html>
```

或者，使用外部CSS文件：

1. 创建一个CSS文件（比如`styles.css`），并添加下面的CSS代码：

```css
/* styles.css文件 */
a {
  text-decoration: none;
}
```

2. 在HTML文件中引入这个CSS文件：

```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Remove Link Underline</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>


<a href="https://www.example.com">Visit Example.com</a>

</body>
</html>
```

使用CSS。这会删除`a`和`u`元素中的下划线：

    a, u {
      text-decoration: none;
    }
    

有时您需要覆盖元素的其他样式，在这种情况下您可以`!important`在规则上使用修饰符：

    a {
      text-decoration: none !important;
    }

CSS 是

    text-decoration: none;
    

和

    text-decoration: underline;

**这将删除您的颜色以及锚标记存在的下划线**

    a {
      text-decoration: none;
    }
    
    a:hover {
      color: white;
      text-decoration: none;
      cursor: pointer;
    }

最简单的选择是这样的：

    <a style="text-decoration: none">No underline</a>
    

当然，将 CSS 与 HTML 混合（即内联 CSS）并不是一个好主意，尤其是当您`a`到处使用标签时。  
这就是为什么最好将其添加到样式表中：

    a {
        text-decoration: none;
    }
    

或者甚至是 JS 文件中的这段代码：

    var els = document.getElementsByTagName('a');
    
    for (var el = 0; el < els.length; el++) {
        els[el].style["text-decoration"] = "none";
    }

使用 CSS 删除`text-decoration`s。

    a {
      text-decoration: none;
    }

CSS 如何删除锚链接 Link 的下划线?

`!important` 在 CSS 中是一个特殊的声明，用于提高一个 CSS 规则的优先级。当多个样式冲突时，即多个规则应用于同一元素的同一个属性，通常会根据特定的优先规则（称为层叠顺序）来决定哪个规则最终会被应用。层叠顺序考虑了源代码的顺序、选择器的特异性以及继承等因素。

使用 `!important` 可以覆盖层叠顺序中的其他规则，即使那些规则本身的特异性更高或在源代码中出现得更晚。这意味着，即便是内联样式，也可能被包含 `!important` 的样式表中的规则覆盖，因为内联样式通常有更高的优先级。

但是，滥用 `!important` 可能会导致 CSS 变得难以维护，因为它破坏了层叠样式表的自然层叠规则。通常建议只在确实必要时（比如需要覆盖第三方组件的样式，且其他方法不可行时）使用 `!important`。

举个例子，假设你有一个页面上的按钮，它在大部分情况下应该是蓝色的，但在一个特定的模块中你希望它是红色的。你可能会这样写 CSS：

```css
/* 通用样式，应用于所有按钮 */
.button {
    color: blue;
}

/* 特定模块的按钮颜色 */
.module .button {
    color: red !important;
}
```

在这个例子中，即使 `.module .button` 的选择器特异性高于 `.button`，`!important` 仍然确保了所有 `.module` 类下的按钮都会是红色的，即便是后面有更特定的规则试图将按钮的颜色设置为非红色。

从本质上讲，它的意思就是它所说的； “这很重要，忽略后续规则以及任何常见的[特殊性](https://stackoverflow.com/q/2809024/1497596)问题，应用_此_规则！”

在正常使用中，外部样式表中定义的规则会被`head`文档中定义的样式所否决，而文档中定义的样式又会被元素本身内的内联样式所否决（假设选择器具有相同的特异性）。使用“属性”(?) 定义规则`!important`可以消除有关“较晚”规则覆盖“较早”规则的正常担忧。

此外，通常，更具体的规则将覆盖不太具体的规则。所以：

    a {
        /* css */
    }
    

通常会被以下因素否决：

    body div #elementID ul li a {
        /* css */
    }
    

由于后一个选择器更具体（通常，在哪里找到更具体的选择器（在样式表或`head`外部样式表中）并不重要），它_仍然_会覆盖不太具体的选择器（内联样式属性将_始终_覆盖“more-”或“less-”特定选择器，因为它_总是_更具体。

但是，如果您添加`!important`到不太具体的选择器的 CSS 声明，它将具有优先权。

使用`!important`有它的目的（尽管我很难想到它们），但这很像使用核爆炸来阻止狐狸杀死你的鸡;是的，狐狸会被杀死，但鸡也会被杀死。还有邻居。

它还使调试 CSS 成为一场噩梦（根据个人经验）。

> !important 规则是一种让你的 CSS 级联的方法，但也有你认为最重要的规则总是被应用。具有 !important 属性的规则将始终被应用，无论该规则出现在 CSS 文档中的何处。

所以，如果你有以下情况：

    .class {
       color: red !important;
    }
    .outerClass .class {
       color: blue;
    }
    

重要的规则将被应用（不计算[特殊性](http://www.stuffandnonsense.co.uk/archives/images/specificitywars-05v2.jpg)）

我相信`!important`CSS1中出现了所以每个浏览器都支持它（IE4到IE6部分实现，IE7+完整）

另外，您不想经常使用它，因为如果您与其他人一起工作，您可以覆盖其他属性。

`!important`是 CSS1 的一部分。

支持的浏览器：IE5.5+、Firefox 1+、Safari 3+、Chrome 1+。

这意味着，类似：

_如果周围没有什么重要的事情，就用我吧！_

不能说得更好。

当按原点排序完成时，它用于影响 CSS 级联中的排序。它与其他答案中所述的特异性无关。

以下是从最低到最高的优先级：

1.  浏览器样式
2.  用户样式表声明（不带 !important）
3.  作者样式表声明（不带 !important）
4.  !重要的作者样式表
5.  !重要的用户样式表

**在**此之后，规则的特殊性仍然发挥着作用。

参考：

*   [http://www.w3.org/TR/CSS2/cascade.html#cascade](http://www.w3.org/TR/CSS2/cascade.html#cascade)
*   [https://russmaxdesign.github.io/maxdesign-slides/02-css/207-css-cascade.html](https://russmaxdesign.github.io/maxdesign-slides/02-css/207-css-cascade.html)

它改变了 css 级联覆盖优先级的规则。请参阅[CSS2 规范](http://www.w3.org/TR/CSS2/cascade.html#important-rules)。

CSS 中的 important 是什么作用？

CSS 的 `word-break` 和 `word-wrap`（也称为 `overflow-wrap`）是控制文本换行行为的属性。它们的作用略有不同，可以用于处理文本在容器内溢出时的情况。

### word-break

`word-break` 属性主要用于指定如何在单词内部进行换行。

- `normal`：使用默认的换行规则。
- `break-all`：允许在单词内部任意位置进行换行。适用于多字节字符（如中文、日文、韩文等），也会对非多字节字符（如英文）起作用，甚至在单词中间也可能换行。
- `keep-all`：CJK（中文、日文、韩文）脚本中，不允许词内换行，但非CJK脚本表现得像 `normal`。

**举例：**

```css
.word-break-example {
  word-break: break-all;
}
```

在这个例子中，如果有一个很长的英文单词或者字符串没有空格，并且它超过了容器的宽度，它会在容器边界内的任何位置换行，不考虑单词边界。

### word-wrap / overflow-wrap

`word-wrap`（在 CSS3 中被重命名为 `overflow-wrap`）属性指定了当单词太长而无法放在其容器内时，是否应该被中断到下一行。

- `normal`：单词不会被分割，只会在允许的断字点换行。
- `break-word`：在长单词或 URL 地址内部进行换行，以避免文本溢出其包含元素。

**举例：**

```css
.word-wrap-example {
  word-wrap: break-word;
}
```

或者使用 `overflow-wrap`:

```css
.overflow-wrap-example {
  overflow-wrap: break-word;
}
```

在这两个例子中，如果文本包含一个长单词，这个单词会在容器边缘处被断开，并继续在下一行显示，从而避免溢出容器。

### 总结

两者的区别在于对于单词内部断行的处理：

- 使用 `word-break: break-all;` 时，长单词和连续的非空白字符序列将在任何字符之间断开，以确保不会溢出容器。
- 使用 `word-wrap: break-word;`（或 `overflow-wrap: break-word;`）时，文本只有在必要时才会在单词内部断行，更倾向于在保持单词完整性的同时防止溢出。

在实际使用时，`word-wrap: break-word;` 通常被认为更优雅，因为它会尽可能保持单词的完整性。而 `word-break: break-all;` 可能会在不理想的位置断开单词，从而影响阅读体验。不过，对于某些语言（如中文），这两个属性的效果可能相似，因为中文不依赖空格分隔单词。

`word-wrap: break-word`最近更改为`overflow-wrap: break-word`

*   会将长单词换行到下一行。
*   调整不同的单词，使它们不会在中间中断。

`word-break: break-all`

*   无论是连续的单词还是多个单词，都会在宽度限制的边缘将它们分开。 （即即使在同一个单词的字符内）

因此，如果您有许多动态获取内容的固定大小的跨度，您可能更喜欢使用`word-wrap: break-word`，因为这样只有连续的单词才会在中间被打破，并且如果它是一个包含许多单词的句子，则会调整空格以获得完整的单词（一个字内没有中断）。

如果不重要的话，就选其中一个吧。

[讨论这些的 W3 规范](http://www.w3.org/TR/css3-text/)似乎表明，这`word-break: break-all`是要求 CJK（中文、日文和韩文）文本的特定行为，而`word-wrap: break-word`是更一般的、不支持 CJK 的行为。

对于`word-break`，一个很长的单词从它应该开始的位置开始，并且根据需要将其断开：

    [X] I am a text that 0123
    4567890123456789012345678
    90123456789 want to live
    inside this narrow paragr
    aph.
    

但是，使用 时`word-wrap`，很长的单词_将不会_从应开始的位置开始。

它会换行到下一行，然后根据需要中断

    [X] I am a text that
    012345678901234567890123
    4567890123456789 want to
    live inside this narrow
    paragraph.

`word-wrap`已更名为`overflow-wrap`“可能”以避免这种混乱。

现在这就是我们所拥有的：

溢出包装
----

> Overflow **\-wrap**属性用于指定浏览器是否可以在单词中换行，以防止当原本不可分割的字符串太长而无法放入其包含框时溢出。

可能的值：

*   **正常**：表示行只能在正常的单词断点处断行。
    
*   **break-word**：表示如果行中没有其他可接受的断点，则通常不可断的单词可以在任意点处断。
    

[来源](https://developer.mozilla.org/en-US/docs/Web/CSS/overflow-wrap)。

断词
--

> word **\-break** CSS 属性用于指定是否在单词内换行。

*   **正常**：使用默认换行规则。
*   **break-all ：可以在非**[CJK](https://en.wikipedia.org/wiki/CJK_characters) （中文/日文/韩文）文本的任何字符之间插入分词符。
*   **keep-all**：不允许 CJK 文本断字。非 CJK 文本行为与正常文本行为相同。

[来源](https://developer.mozilla.org/en-US/docs/Web/CSS/word-break)。

* * *

现在回到你的问题。**溢出换行**和**断字**之间的主要区别在于，前者确定_溢出_情况下的行为，而后者确定_正常_情况（无溢出）下的行为。当容器没有足够的空间来容纳文本时，就会发生溢出_情况_。在这种情况下断线没有帮助，因为没有空间（想象一个具有固定宽度和高度的盒子）。

所以：

*   `overflow-wrap: break-word`：在溢出的情况下，中断单词。
*   `word-break: break-all`：正常情况下，将行尾的单词打断即可。溢出是不必要的。

至少在 Firefox（自 v24 起）和 Chrome（自 v30 起）中，当应用于元素中的内容时`table`：

`word-wrap:break-word`

实际上不会导致长字换行，这可能导致表超出其容器的边界；

`word-break:break-all`

_将_导致文字换行，并且表格适合其容器。

![在此输入图像描述](https://i.stack.imgur.com/ksVnE.png)

[jsfiddle 演示](http://jsfiddle.net/SDGAX/1/)。

CSS 中 word : break-all 和 word: wrap break有什么区别？

`offsetWidth`、`clientWidth`、`scrollWidth` 以及 `height` 是与 HTML 元素的大小和滚动相关的不同属性。下面我将详细解释它们之间的区别：

### offsetWidth

- **定义**: `offsetWidth` 是元素的布局宽度，包括元素的可视宽度、边框（border）、内边距（padding），但不包括外边距（margin）。
- **使用场景**: 当你需要元素的整体宽度时，包括它的边框和内边距。
- **例子**: 如果一个元素的宽度为100px，左右内边距分别为10px，左右边框宽度分别为1px，那么`offsetWidth`将会是 100 + 10 + 10 + 1 + 1 = 122px。

### clientWidth

- **定义**: `clientWidth` 是元素的内部可视宽度，包括内边距，但不包括边框和垂直滚动条（如果有的话），也不包括外边距。
- **使用场景**: 当你想要获取元素内容区域加上内边距的宽度，但不包括边框或滚动条。
- **例子**: 对于上面同一个元素，`clientWidth` 将会是 100 + 10 + 10 = 120px（假设没有垂直滚动条）。

### scrollWidth

- **定义**: `scrollWidth` 是元素的完整内容宽度，包括因为溢出被隐藏的部分。它包括内边距，但不包括边框和垂直滚动条（如果有的话），也不包括外边距。
- **使用场景**: 当你需要获取元素内容实际占用的总宽度，包括看得见和看不见（溢出部分）的内容。
- **例子**: 如果上面的元素内有足够的内容使其出现水平滚动条，而内容的实际宽度为300px，那么`scrollWidth`将会是 300 + 10 + 10 = 320px。

### height

- **定义**: `height` 不是一个标准的 DOM 属性，它通常指的是通过 CSS 设置的元素的高度（不包括内边距、边框或外边距）。
- **使用场景**: 当你需要定义或获取元素的内容区域的高度时。
- **例子**: 如果你通过 CSS 设置了`height: 200px;`，那么这个元素的内容区域高度就是200px，不考虑其他任何因素。

总结一下，`offsetWidth`和`clientWidth`都是考虑元素在页面布局中占用的实际空间，而`scrollWidth`是元素内容的实际宽度，不管是否可见。另一方面，`height`通常是通过CSS设置的属性，指定了元素的内容区域的高度。这些属性都是针对元素宽度和高度的不同方面的计量。

CSS 盒子模型相当复杂，尤其是在滚动内容时。虽然浏览器使用 CSS 中的值来绘制框，但如果您只有 CSS，则使用 JS 确定所有尺寸并不简单。

这就是为什么每个元素都有六个 DOM 属性以方便您使用：`offsetWidth`、`offsetHeight`、`clientWidth`、`clientHeight`和`scrollWidth`。`scrollHeight`这些是表示当前视觉布局的只读属性，并且它们都是_整数_（因此可能会出现舍入错误）。

让我们详细了解一下它们：

*   `offsetWidth`, `offsetHeight`: 包含所有边框的视觉框的大小。可以通过添加`width`/以及 paddings 和 borders来计算`height`，如果元素有`display: block`
*   `clientWidth`, `clientHeight`：框内容的可视部分，不包括边框或滚动条，但包括填充。不能直接从CSS计算，取决于系统的滚动条大小。
*   `scrollWidth`, `scrollHeight`：框所有内容的大小，包括当前隐藏在滚动区域之外的部分。不能直接从CSS计算，要看内容。

[![CSS2 盒子模型](https://i.stack.imgur.com/5AAyW.png)](http://jsfiddle.net/y8Y32/25/)

### 尝试一下：[jsFiddle](http://jsfiddle.net/y8Y32/25/)

* * *

由于`offsetWidth`考虑了滚动条宽度，我们可以使用它通过公式计算滚动条宽度

    scrollbarWidth = offsetWidth - clientWidth - getComputedStyle().borderLeftWidth - getComputedStyle().borderRightWidth
    

不幸的是，我们可能会遇到舍入误差，因为`offsetWidth`和`clientWidth`始终是整数，而实际大小可能是缩放级别不是 1 的小数。

请注意，这

    scrollbarWidth = getComputedStyle().width + getComputedStyle().paddingLeft + getComputedStyle().paddingRight - clientWidth
    

在 Chrome 中无法可靠**地**工作，因为 Chrome 返回时`width`滚动条已被减去。 （此外，Chrome 将 paddingBottom 渲染到滚动内容的底部，而其他浏览器则不会）

我创建了一个更全面、更清晰的版本，有些人可能会发现它对于记住哪个名称对应哪个值很有用。我使用 Chrome 开发工具的颜色代码和对称组织的标签，以便更快地进行类比：

[![在此输入图像描述](https://i.stack.imgur.com/Cl1IA.png)](https://i.stack.imgur.com/Cl1IA.png)

*   注 1：`clientLeft`如果文本方向设置为从右到左，还包括垂直滚动条的宽度（因为在这种情况下滚动条显示在左侧）
    
*   注 2：最外面的线代表最接近的**_定位_**`position`父元素（其属性设置为不同于 `static`或 的值的元素`initial`）。因此，如果直接容器不是**_定位_** 元素，则该行不代表层次结构中的第一个容器，而是代表层次结构中更高的另一个元素。如果没有 找到**_定位的_**`html`父元素，浏览器将采用or`body` 元素作为参考
    

* * *

希望有人觉得它有用，只是我的 2 美分；）

如果您想使用scrollWidth来获取**“真实”** **内容宽度/高度**（因为内容可能比css定义的宽度/高度框更大），则scrollWidth **/Height非常不可靠**，因为某些浏览器似乎“移动”了paddingRIGHT & paddingBOTTOM 如果内容太大。然后，他们将填充物放置在“太宽/太高的内容”的右侧/底部（见下图）。

**\==>**因此，要在某些浏览器中获得真实内容宽度，您必须从滚动宽度中减去两个填充，而在某些浏览器中，您只需减去左侧填充。

我找到了一个解决方案，并想将其添加为评论，但不允许。所以我拍了这张照片，并使其在“移动的填充”和“不可靠的滚动宽度”方面变得更加清晰。**在蓝色区域中，您可以找到有关如何获得“真实”内容宽度的解决方案！**

希望这有助于让事情变得更加清晰！

[![在此输入图像描述](https://i.stack.imgur.com/JY33m.png)](https://i.stack.imgur.com/JY33m.png)

MDN 上有一篇很好的文章解释了这些概念背后的理论： [https ://developer.mozilla.org/en-US/docs/Web/API/CSS\_Object\_Model/Det​​ermining\_the\_dimensions\_of\_elements](https://developer.mozilla.org/en-US/docs/Web/API/CSS_Object_Model/Determining_the_dimensions_of_elements)

它还解释了boundingClientRect的宽度/高度与offsetWidth/offsetHeight之间的重要概念差异。

然后，为了证明这个理论是对还是错，你需要一些测试。这就是我在这里所做的：[https://github.com/lingtalfi/dimensions-cheatsheet](https://github.com/lingtalfi/dimensions-cheatsheet)

它正在测试 chrome53、ff49、safari9、edge13 和 ie11。

测试结果证明该理论总体上是正确的。对于测试，我创建了 3 个 div，每个 div 包含 10 个 lorem ipsum 段落。一些 CSS 应用于它们：

    .div1{
        width: 500px;
        height: 300px;
        padding: 10px;
        border: 5px solid black;
        overflow: auto;
    }
    .div2{
        width: 500px;
        height: 300px;
        padding: 10px;
        border: 5px solid black;
        box-sizing: border-box;
        overflow: auto;
    }
    
    .div3{
        width: 500px;
        height: 300px;
        padding: 10px;
        border: 5px solid black;
        overflow: auto;
        transform: scale(0.5);
    }
    

结果如下：

*   分区1
    
    *   偏移宽度：530（chrome53、ff49、safari9、edge13、ie11）
        
    *   偏移高度：330（chrome53、ff49、safari9、edge13、ie11）
        
    *   bcr.宽度：530（chrome53、ff49、safari9、edge13、ie11）
        
    *   bcr.高度：330（chrome53、ff49、safari9、edge13、ie11）
        
    *   客户端宽度：505（chrome53、ff49、safari9）
        
    *   客户端宽度：508（边缘13）
        
    *   客户端宽度：503（即11）
        
    *   客户端高度：320（chrome53、ff49、safari9、edge13、ie11）
        
    *   滚动宽度：505（chrome53、safari9、ff49）
        
    *   滚动宽度：508（边缘13）
        
    *   滚动宽度：503（即11）
        
    *   滚动高度：916（chrome53、safari9）
        
    *   滚动高度：954（ff49）
        
    *   滚动高度：922（边缘13，ie11）
        
*   分区2
    
    *   偏移宽度：500（chrome53、ff49、safari9、edge13、ie11）
        
    *   偏移高度：300（chrome53、ff49、safari9、edge13、ie11）
        
    *   bcr.width：500（chrome53、ff49、safari9、edge13、ie11）
        
    *   bcr.高度：300（chrome53、ff49、safari9）
        
    *   bcr.高度：299.9999694824219（edge13，ie11）
        
    *   客户端宽度：475（chrome53、ff49、safari9）
        
    *   客户端宽度：478（边缘13）
        
    *   客户端宽度：473（ie11）
        
    *   客户端高度：290（chrome53、ff49、safari9、edge13、ie11）
        
    *   滚动宽度：475（chrome53、safari9、ff49）
        
    *   滚动宽度：478（边缘13）
        
    *   滚动宽度：473（即11）
        
    *   滚动高度：916（chrome53、safari9）
        
    *   滚动高度：954（ff49）
        
    *   滚动高度：922（边缘13，ie11）
        
*   分区3
    
    *   偏移宽度：530（chrome53、ff49、safari9、edge13、ie11）
        
    *   偏移高度：330（chrome53、ff49、safari9、edge13、ie11）
        
    *   bcr.宽度：265（chrome53、ff49、safari9、edge13、ie11）
        
    *   bcr.高度：165（chrome53、ff49、safari9、edge13、ie11）
        
    *   客户端宽度：505（chrome53、ff49、safari9）
        
    *   客户端宽度：508（边缘13）
        
    *   客户端宽度：503（即11）
        
    *   客户端高度：320（chrome53、ff49、safari9、edge13、ie11）
        
    *   滚动宽度：505（chrome53、safari9、ff49）
        
    *   滚动宽度：508（边缘13）
        
    *   滚动宽度：503（即11）
        
    *   滚动高度：916（chrome53、safari9）
        
    *   滚动高度：954（ff49）
        
    *   滚动高度：922（边缘13，ie11）
        

因此，除了edge13和ie11中boundingClientRect的高度值（299.9999694824219而不是预期的300）之外，结果证实了其背后的理论是有效的。

从那里，这是我对这些概念的定义：

*   offsetWidth/offsetHeight：布局边框框的尺寸
*   boundingClientRect：渲染边框的尺寸
*   clientWidth/clientHeight：布局内边距框可见部分的尺寸（不包括滚动条）
*   scrollWidth/scrollHeight：布局填充框的尺寸（如果不受滚动条约束）

注意：默认垂直滚动条的宽度在edge13中为12px，在chrome53、ff49和safari9中为15px，在ie11中为17px（通过截图在photoshop中测量，并通过测试结果证明正确）。

但是，在某些情况下，您的应用程序可能未使用默认的垂直滚动条宽度。

因此，考虑到这些概念的定义，垂直滚动条的宽度应该等于（伪代码）：

*   布局尺寸：offsetWidth - clientWidth - (borderLeftWidth + borderRightWidth)
    
*   渲染尺寸：boundingClientRect.width - clientWidth - (borderLeftWidth + borderRightWidth)
    

请注意，如果您不了解布局与渲染，请阅读 mdn 文章。

另外，如果您有其他浏览器（或者如果您想亲自查看测试结果），您可以在此处查看我的测试页面：[http://codepen.io/lingtalfi/pen/BLdBdL](http://codepen.io/lingtalfi/pen/BLdBdL)

我的个人备忘单，涵盖：

[![DOM 元素尺寸](https://docs.google.com/drawings/d/e/2PACX-1vSL7XQsLsiABaVgInqMQb50jbzBbXTXgPlax5Nf1mIjE4ANDXWRBUzZTRCim8eX6ILpCWpYwuVyJJMs/pub?w=7964&h=2011)](https://docs.google.com/drawings/d/e/2PACX-1vSL7XQsLsiABaVgInqMQb50jbzBbXTXgPlax5Nf1mIjE4ANDXWRBUzZTRCim8eX6ILpCWpYwuVyJJMs/pub?w=7964&h=2011)

*   `.offsetWidth`/`.offsetHeight`
*   `.clientWidth`/`.clientHeight`
*   `.scrollWidth`/`.scrollHeight`
*   `.scrollLeft`/`.scrollTop`
*   `.getBoundingClientRect()`

带有小/简单/非全合一的图表:)

* * *

👁 查看全尺寸：[https://docs.google.com/drawings/d/1bOOJnkN5G\_lBs3Oz9NfQQH1I0aCrX5EZYPY3mu3\_ROI/edit ?usp=sharing](https://docs.google.com/drawings/d/1bOOJnkN5G_lBs3Oz9NfQQH1I0aCrX5EZYPY3mu3_ROI/edit?usp=sharing)

Web 页面中 fffsetwidth clientwidth scrollwidth和 height 分别有什么不同？

CSS `filter` 属性可以用于在网页元素上应用图形效果，例如模瑕、亮度、对比度等。它不仅可以应用于普通的元素，也可以应用于背景图像。要对元素的背景图像使用 `filter` 操作，通常有以下几种方法：

1. **直接在元素上应用：** 可以直接在包含背景图像的元素上使用 `filter` 属性。这将对元素整体（包括文本内容和背景图像）应用滤镜效果。

```css
.background-filter {
  background-image: url('image.jpg');
  filter: blur(5px);  /* 应用模糊效果 */
}
```

2. **使用伪元素：** 如果您只想对背景图像应用 `filter` 而不影响其他内容，可以使用伪元素来实现。通过将背景图像应用于 `::before` 或 `::after` 伪元素，并在该伪元素上使用 `filter`，我们可以确保只对背景图像应用滤镜效果。

```css
.background-filter::before {
  content: '';
  position: absolute;
  top: 0;
  right: 0;
  bottom: 0;
  left: 0;
  background-image: url('image.jpg');
  background-size: cover;
  filter: blur(5px);  /* 应用模糊效果 */
}

.background-filter {
  position: relative;
  z-index: 1;
}
```

3. **使用父元素的滤镜：** 还可以将滤镜效果应用于包含背景图像的元素的父元素。这种方法会让背景图像和任何子元素都受到滤镜效果的影响。

```css
.background-filter-parent {
  filter: blur(5px);  /* 应用模糊效果 */
}

.background-filter-child {
  background-image: url('image.jpg');
}
```

在这些例子中，我们使用了 `blur()` 函数作为 `filter` 的值，这将对选中的元素应用模糊效果。CSS `filter` 还支持其他函数，例如 `brightness()`, `contrast()`, `grayscale()`, `sepia()`, `hue-rotate()`, `invert()`, `opacity()` 和 `saturate()`，可以根据需要组合使用这些函数来达到不同的视觉效果。

您将必须使用两种不同的容器，一种用于背景图像，另一种用于您的内容。

在示例中，我创建了两个容器，`.background-image`并且`.content`.

两者都与`position: fixed`和 一起放置`left: 0; right: 0;`。显示它们的差异来自于`z-index`为元素设置不同的值。

    .background-image {
      position: fixed;
      left: 0;
      right: 0;
      z-index: 1;
      display: block;
      background-image: url('https://i.stack.imgur.com/CjzQS.jpg');
      width: 1200px;
      height: 800px;
      -webkit-filter: blur(5px);
      -moz-filter: blur(5px);
      -o-filter: blur(5px);
      -ms-filter: blur(5px);
      filter: blur(5px);
    }
    
    .content {
      position: fixed;
      left: 0;
      right: 0;
      z-index: 9999;
      margin-left: 20px;
      margin-right: 20px;
    }

    <div class="background-image"></div>
    <div class="content">
      <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis aliquam erat in ante malesuada, facilisis semper nulla semper. Phasellus sapien neque, faucibus in malesuada quis, lacinia et libero. Sed sed turpis tellus. Etiam ac aliquam tortor, eleifend
        rhoncus metus. Ut turpis massa, sollicitudin sit amet molestie a, posuere sit amet nisl. Mauris tincidunt cursus posuere. Nam commodo libero quis lacus sodales, nec feugiat ante posuere. Donec pulvinar auctor commodo. Donec egestas diam ut mi adipiscing,
        quis lacinia mauris condimentum. Quisque quis odio venenatis, venenatis nisi a, vehicula ipsum. Etiam at nisl eu felis vulputate porta.</p>
      <p>Fusce ut placerat eros. Aliquam consequat in augue sed convallis. Donec orci urna, tincidunt vel dui at, elementum semper dolor. Donec tincidunt risus sed magna dictum, quis luctus metus volutpat. Donec accumsan et nunc vulputate accumsan. Vestibulum
        tempor, erat in mattis fringilla, elit urna ornare nunc, vel pretium elit sem quis orci. Vivamus condimentum dictum tempor. Nam at est ante. Sed lobortis et lorem in sagittis. In suscipit in est et vehicula.</p>
    </div>

运行代码片段隐藏结果

展开片段

[Matthew Wilcoxson](https://stackoverflow.com/users/266375/matthew-wilcoxson)建议使用`.content::before`以避免第二个 div 的实现： https: [//codepen.io/akademy/pen/FlkzB](https://codepen.io/akademy/pen/FlkzB)

消除对额外元素的需求，同时使内容适合文档流，而不是像其他解决方案那样固定/绝对。

使用实现

    .content {
      /* this is needed or the background will be offset by a few pixels at the top */
      overflow: auto;
      position: relative;
    }
    
    .content::before {
      content: "";
      position: fixed;
      left: 0;
      right: 0;
      z-index: -1;
    
      display: block;
      background-image: url('https://i.stack.imgur.com/CjzQS.jpg');
      background-size:cover;
      width: 100%;
      height: 100%;
    
      -webkit-filter: blur(5px);
      -moz-filter: blur(5px);
      -o-filter: blur(5px);
      -ms-filter: blur(5px);
      filter: blur(5px);
    }

    <div class="content">
    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
    </div>

运行代码片段隐藏结果

展开片段

如果您有兴趣删除边缘的白色边框，请使用宽度和高度`110%`以及左侧和顶部`-5%`。这会稍微放大你的背景，但不应该有纯色从边缘渗入。

显示代码片段

    .content {
      /* this is needed or the background will be offset by a few pixels at the top */
      overflow: auto;
      position: relative;
    }
    
    .content::before {
      content: "";
      position: fixed;
      top: -5%;
      left: -5%;
      right: -5%;
      z-index: -1;
    
      display: block;
      background-image: url('https://i.stack.imgur.com/CjzQS.jpg');
      background-size:cover;
      width: 110%;
      height: 110%;
    
      -webkit-filter: blur(5px);
      -moz-filter: blur(5px);
      -o-filter: blur(5px);
      -ms-filter: blur(5px);
      filter: blur(5px);
    }

    <div class="content">
    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
    </div>

Run code snippetHide results

Expand snippet

正如其他答案中所述，这可以通过以下方式实现：

*   作为背景的模糊图像的副本。
*   可以过滤然后定位在内容后面的伪元素。

您还可以使用[`backdrop-filter`](https://developer.mozilla.org/en-US/docs/Web/CSS/backdrop-filter)
-------------------------------------------------------------------------------------------

有一个受支持的属性，称为，目前 Chrome、Firefox、 [Edge](https://wpdev.uservoice.com/forums/257854-microsoft-edge-developer/suggestions/9160189-backdrop-filters)、Safari 和 iOS Safari`backdrop-filter`支持该属性（有关统计信息，请参阅[caniuse.com](http://caniuse.com/#feat=css-backdrop-filter)）。[](https://wpdev.uservoice.com/forums/257854-microsoft-edge-developer/suggestions/9160189-backdrop-filters)[](http://caniuse.com/#feat=css-backdrop-filter)

来自[Mozilla 开发文档](https://developer.mozilla.org/en-US/docs/Web/CSS/backdrop-filter)：

> background-filter 属性提供诸如对元素后面的区域进行模糊或颜色偏移等效果，然后可以通过调整元素的透明度/不透明度来透过该元素看到这些效果。

请参阅[caniuse.com](http://caniuse.com/#feat=css-backdrop-filter)了解使用情况统计信息。

你会像这样使用它。如果您不想让里面的内容变得模糊，请使用实用程序类`.u-non-blurred`

    .background-filter::after {
      -webkit-backdrop-filter: blur(5px); /* Use for Safari 9+, Edge 17+ (not a mistake) and iOS Safari 9.2+ */
      backdrop-filter: blur(5px); /* Supported in all major browsers */
    
      content: "";
      display: block;
      position: absolute;
      width: 100%; height: 100%;
      top: 0;
    }
    
    .background-filter {
      position: relative;
    }
    
    .background {
      background-image: url('https://upload.wikimedia.org/wikipedia/en/6/62/Kermit_the_Frog.jpg');
      width: 200px;
      height: 200px;
    }
    
    /* Use for child content that should not be blurred */
    .u-non-blurred {
      position: relative;
      z-index: 1;
    }

    <div class="background background-filter">
      <h1 class="u-non-blurred">Kermit D. Frog</h1>
    </div>

运行代码片段隐藏结果

展开片段

为此，您需要重新构造 HTML。您必须模糊整个元素才能模糊背景。因此，如果您只想模糊背景，则它必须是自己的元素。

以下是纯 CSS 中现代浏览器的简单解决方案，带有“before”伪元素，如 Matthew Wilcoxson 的解决方案。

为了避免需要访问伪元素来更改 JavaScript 中的图像和其他属性，只需使用`inherit`作为值并通过父元素访问它们（此处`body`）。

    body::before {
        content: ""; /* Important */
        z-index: -1; /* Important */
        position: inherit;
        left: inherit;
        top: inherit;
        width: inherit;
        height: inherit;
        background-image: inherit;
        background-size: cover;
        filter: blur(8px);
    }
    
    body {
      background-image: url("xyz.jpg");
      background-size: 0 0;  /* Image should not be drawn here */
      width: 100%;
      height: 100%;
      position: fixed; /* Or absolute for scrollable backgrounds */
    }

CSS 如何对背景图像使用 filter 操作？

CSS可以通过定义关键帧动画（`@keyframes`）来实现页面加载时的淡入效果。首先，你需要设置初始状态让元素透明度为0（即元素完全透明），然后随着时间的推移逐渐改变透明度至1（元素完全不透明）。这样就可以创建一个淡入效果，当页面加载时元素会逐渐显示。

以下是一个简单的示例：

```css
/* 定义淡入效果的关键帧 */
@keyframes fadeIn {
    from {
        opacity: 0; /* 开始时透明度为0 */
    }
    to {
        opacity: 1; /* 结束时透明度为1 */
    }
}

/* 应用于页面元素 */
.element-to-fade-in {
    opacity: 0;      /* 初始透明度设置为0 */
    animation: fadeIn 2s ease-in forwards; /* 应用淡入效果，持续时间2秒，动画曲线为 ease-in，动画结束后保持最终状态 */
}
```

在上面的CSS中，`.element-to-fade-in` 类将被添加到需要淡入效果的HTML元素上。`animation` 属性指定了动画的名称 `fadeIn`，动画的持续时间（`2s`），动画时间函数（`ease-in`），以及一个 `forwards` 填充模式，表示动画完成后，元素将保持其最后一帧的样式。

当页面加载并且元素渲染时，动画会自然地开始，元素从完全透明慢慢变为完全不透明，从而达到淡入的效果。

为了确保元素在页面加载时立即开始动画，你可能需要将CSS添加到 `<head>` 标签中，或者使用内联样式。此外，确保没有其他CSS规则覆盖了你的淡入效果设置。

如果你的页面有很多元素需要应用淡入效果，你可以将这个类应用到所有这些元素上，或者如果它们共享一个父元素，你也可以将动画应用到父元素上，这样所有的子元素将会一同呈现淡入效果。

请注意，CSS动画的支持取决于浏览器的兼容性，但现代浏览器大多支持CSS3的关键帧动画。

方法一：
----

如果您正在寻找自调用过渡，那么您应该使用[CSS 3 Animations](https://developer.mozilla.org/en-US/docs/Web/CSS/animation)。它们也不受支持，但这正是它们的用途。

### CSS

    #test p {
        margin-top: 25px;
        font-size: 21px;
        text-align: center;
    
        -webkit-animation: fadein 2s; /* Safari, Chrome and Opera > 12.1 */
           -moz-animation: fadein 2s; /* Firefox < 16 */
            -ms-animation: fadein 2s; /* Internet Explorer */
             -o-animation: fadein 2s; /* Opera < 12.1 */
                animation: fadein 2s;
    }
    
    @keyframes fadein {
        from { opacity: 0; }
        to   { opacity: 1; }
    }
    
    /* Firefox < 16 */
    @-moz-keyframes fadein {
        from { opacity: 0; }
        to   { opacity: 1; }
    }
    
    /* Safari, Chrome and Opera > 12.1 */
    @-webkit-keyframes fadein {
        from { opacity: 0; }
        to   { opacity: 1; }
    }
    
    /* Internet Explorer */
    @-ms-keyframes fadein {
        from { opacity: 0; }
        to   { opacity: 1; }
    }
    
    /* Opera < 12.1 */
    @-o-keyframes fadein {
        from { opacity: 0; }
        to   { opacity: 1; }
    }
    

### 演示

*   [http://jsfiddle.net/SO\_AMK/VV2ek/](http://jsfiddle.net/SO_AMK/VV2ek/)

### 浏览器支持

所有现代浏览器和 Internet Explorer 10（及更高版本）：[http://caniuse.com/#feat=css-animation](http://caniuse.com/#feat=css-animation)

  

方法二：
----

或者，您可以使用 jQuery（或纯 JavaScript；请参阅第三个代码块）来更改加载时的类：

### jQuery

    $("#test p").addClass("load");​
    

### CSS

    #test p {
        opacity: 0;
        font-size: 21px;
        margin-top: 25px;
        text-align: center;
    
        -webkit-transition: opacity 2s ease-in;
           -moz-transition: opacity 2s ease-in;
            -ms-transition: opacity 2s ease-in;
             -o-transition: opacity 2s ease-in;
                transition: opacity 2s ease-in;
    }
    
    #test p.load {
        opacity: 1;
    }
    

### 纯 JavaScript（不在演示中）

    document.getElementById("test").children[0].className += " load";
    

### 演示

*   [http://jsfiddle.net/SO\_AMK/a9dnW/](http://jsfiddle.net/SO_AMK/a9dnW/)

### 浏览器支持

所有现代浏览器和 Internet Explorer 10（及更高版本）：[http://caniuse.com/#feat=css-transitions](http://caniuse.com/#feat=css-transitions)

  

方法三：
----

_或者，您可以使用.Mail_使用的方法：

### jQuery

    $("#test p").delay(1000).animate({ opacity: 1 }, 700);​
    

### CSS

    #test p {
        opacity: 0;
        font-size: 21px;
        margin-top: 25px;
        text-align: center;
    }
    

### 演示

*   [http://jsfiddle.net/SO\_AMK/a9dnW/3/](http://jsfiddle.net/SO_AMK/a9dnW/3/)

### 浏览器支持

**jQuery 1.x**：所有现代浏览器和 Internet Explorer 6（及更高版本）： http: [//jquery.com/browser-support/](http://jquery.com/browser-support/)  
**jQuery 2.x**：所有现代浏览器和 Internet Explorer 9（及更高版本）：[http:// jquery.com/browser-support/](http://jquery.com/browser-support/)

此方法最具交叉兼容性，因为目标浏览器不需要支持 CSS 3 过渡_或_动画。

您可以使用`onload=""`HTML 属性并使用 JavaScript 来调整元素的不透明度样式。

按照您的建议保留 CSS。将 HTML 代码编辑为：

    <body onload="document.getElementById(test).style.opacity='1'">
        <div id="test">
            <p>​This is a test</p>
        </div>
    </body>
    

**这也可以在完成加载时淡入整个页面：**

HTML：

    <body onload="document.body.style.opacity='1'">
    </body>
    

CSS：

    body{ 
        opacity: 0;
        transition: opacity 2s;
        -webkit-transition: opacity 2s; /* Safari */
    }
    

查看[W3Schools](http://en.wikipedia.org/wiki/W3Schools)网站：[过渡和有关](http://www.w3schools.com/css/css3_transitions.asp)[使用 JavaScript 更改样式的](http://www.w3schools.com/js/js_htmldom_css.asp)文章。

回答 @AMK 关于如何在没有 jQuery 的情况下进行转换的问题。我整理了一个非常简单的例子。如果我有时间更多地思考这一点，我也许能够完全消除 JavaScript 代码：

    <style>
        body {
            background-color: red;
            transition: background-color 2s ease-in;
        }
    </style>
    
    <script>
        window.onload = function() {
            document.body.style.backgroundColor = '#00f';
        }
    </script>
    
    <body>
        <p>test</p>
    </body>

CSS 如何在页面加载时添加淡入效果？

在网页设计中，我们常常需要确保页面在打印时的布局与在线浏览时不同。有些元素，比如导航栏、广告或者其他不适合打印的组件，我们在打印版面上通常会选择隐藏。要在打印网页时隐藏某些元素，我们可以使用CSS的媒体查询功能来实现。

以下是一个基本的步骤和示例，说明如何通过CSS隐藏不需要打印的元素：

### 1. 定义媒体查询
使用`@media print`媒体查询来为打印定义特定的CSS规则。这些规则只会在用户尝试打印页面时应用。

```css
@media print {
  /* 在这里编写打印时的CSS规则 */
}
```

### 2. 隐藏不必要的元素
在`@media print`块内，可以选择性地为不需要打印的元素设置`display: none;`规则，这样这些元素在打印预览和打印输出中就不会显示。

```css
@media print {
  .navigation, .sidebar, .footer {
    display: none;
  }
}
```

在上面的例子中，`.navigation`、`.sidebar` 和 `.footer` 类选择器的元素将在打印时被隐藏。

### 3. 调整打印布局
在某些情况下，除了隐藏特定元素外，我们还需要调整剩余内容的布局，以确保打印输出的格式正确。

```css
@media print {
  .content {
    width: 100%;
    margin: 0;
    padding: 0;
  }
}
```

在这个例子中，`.content` 类的元素在打印时会被调整为占据全部可用宽度，并且移除外边距和内边距。

### 示例代码
将以下CSS代码添加到你的网页中，以隐藏`.navigation`类的元素并调整内容宽度，仅在打印时适用：

```css
@media print {
  .navigation {
    display: none;
  }
  
  .content {
    width: 100%;
    margin: 0;
    padding: 0;
  }
}
```

记得，为了保证打印样式的正确应用，你需要在HTML文档的`<head>`标签内正确链接你的CSS文件，或者直接将样式嵌入到`<style>`标签中。

以上即是如何在打印网页时通过CSS隐藏某些元素的方法。这种方式允许我们为打印提供一个更清晰、更专注于内容的版本，同时保留网页本身的功能性和设计美感。

在您的样式表中添加：

    @media print
    {    
        .no-print, .no-print *
        {
            display: none !important;
        }
    }
    

然后`class='no-print'`在 HTML 中添加您不希望出现在打印版本中的内容（或将非打印类添加到现有的类语句中），例如您的按钮。

Bootstrap 3 有[自己**的**类，称为](https://getbootstrap.com/docs/3.3/css/#responsive-utilities-print)：

    hidden-print
    

它的定义如下：

    @media print {
      .hidden-print {
        display: none !important;
      }
    }
    

**您不必自己定义它。**

* * *

在[Bootstrap 4](https://getbootstrap.com/docs/4.3/utilities/display/#display-in-print)和[Bootstrap5](https://getbootstrap.com/docs/5.1/utilities/display/#display-in-print)中，这已更改为：

    .d-print-none

最佳实践是**使用专门用于打印的样式表**，并将其`media`属性设置为`print`。

在其中显示/隐藏要打印在纸张上的元素。

    <link rel="stylesheet" type="text/css" href="print.css" media="print" />

这是一个简单的解决方案，将这个CSS

    @media print{
       .noprint{
           display:none;
       }
    }
    

这是 HTML

    <div class="noprint">
        element that need to be hidden when printing
    </div>

CSS文件

    @media print
    {
        #pager,
        form,
        .no-print
        {
            display: none !important;
            height: 0;
        }
    
    
        .no-print, .no-print *{
            display: none !important;
            height: 0;
        }
    }
    

HTML 标题

    <link href="/theme/css/ui/ui.print.css?version=x.x.x" media="print" rel="stylesheet" type="text/css" >
    

元素

    <div class="no-print"></div>

如何在打印网页时如何隐藏某些元素？

只需使用`resize: none`

    textarea {
       resize: none;
    }
    

您还可以决定仅水平或垂直调整文本区域的大小，如下所示：

`textarea { resize: vertical; }`

`textarea { resize: horizontal; }`

最后， `resize: both`启用调整大小抓取器。

<textarea style="resize:none" name="name" cols="num" rows="num"></textarea>
    

只是一个例子

禁用调整大小选项的文本区域示例

    <textarea CLASS="foo"></textarea>
    
    <style>
    textarea.foo
    {
    resize:none;
    }
    
    </style>

CSS 如何隐藏 Textarea 的大小缩放器样式？

`display: flex` 和 `display: inline-flex` 是 CSS 中的两种显示模式，它们都涉及到了 CSS 的一个模块，叫做弹性盒布局（Flexible Box Layout），简称 Flexbox。Flexbox 是一种一维布局方法，为盒状模型提供了更加灵活的排列方式。

### display: flex
当你给一个元素设置 `display: flex` 属性时，这个元素会成为一个**块级**的弹性容器（flex container），意味着该元素将表现出块级元素的特性。具体来说，有以下几点：

- **块级元素特性**：就像 `display: block` 的元素一样，`display: flex` 的元素会在页面中单独占据一行，前后都会有换行。
- **Flex容器**：该元素内部的直接子元素会成为弹性项目（flex items），并且这些子元素会按照 flex 模型进行排列，不再是默认的块级或者内联流。
- **布局控制**：对于子元素，你可以使用 flexbox 提供的一系列属性来控制它们的对齐、方向、顺序等，例如 `justify-content`, `align-items`, `flex-direction`, `order`, `flex-grow` 等。

例如，如果你有一个导航栏或者一列卡片，可能会希望它们占满整个容器的宽度，并且希望它们能够灵活地伸缩以适应不同屏幕大小，那么 `display: flex` 就是一个很好的选择。

### display: inline-flex
而当你使用 `display: inline-flex` 时，你的元素还是会成为一个弹性容器，但它表现为一个**内联级**的容器。这意味着：

- **内联元素特性**：`display: inline-flex` 的元素不会单独占据一行，它会像 `display: inline` 元素一样，和其他内联元素或者文字在同一行流中排列，除非空间不足以容纳它。
- **Flex容器**：内部子元素的表现与 `display: flex` 一样，会成为弹性项目并根据 flexbox 属性进行排列。
- **排列特性**：尽管 `display: inline-flex` 的元素在外部表现为内联元素，但内部子元素的排列仍然是一个完整的 flexbox 布局环境。

此时，`display: inline-flex` 适用于当你需要一个内容区块在文本流中表现为内联元素，同时还想在这个区块内部使用 flexbox 排列其内部元素。例如，一个小的工具条或按钮组可能就会使用到 `display: inline-flex`。

### 总结
简单来说，最主要的区别在于外部的排列模式，`display: flex` 会让元素表现为块级元素，而 `display: inline-flex` 则是内联元素。选择哪个取决于你想如何在页面流中定位你的弹性容器以及其内部的元素。

`display: inline-flex`不使_弹性项目_内联显示。它使_弹性容器_内联显示。这是`display: inline-flex`和之间的唯一区别`display: flex`。可以在`display: inline-block`和`display: block`以及[几乎任何其他具有内联对应项的显示类型之间](https://stackoverflow.com/questions/24313271/display-property-differences-for-inline-something)进行类似的比较。1

对弹性项目的效果绝对没有区别；无论 Flex 容器是块级还是内联级，Flex 布局都是相同的。特别是，弹性项目本身总是表现得像块级框（尽管它们确实具有内联块的_一些_属性）。您无法内嵌显示弹性项目；否则你实际上就没有弹性布局。

目前尚不清楚“垂直对齐”到底是什么意思，或者为什么您想要内联显示内容，但我怀疑 Flexbox 不是您想要完成的任何任务的正确工具。很可能您正在寻找的只是普通的旧式内联布局（`display: inline`和/或`display: inline-block`），而 Flexbox 不能替代_它_； Flexbox 并不是_每个_人都声称的通用布局解决方案（我这么说是因为这种误解可能是您首先考虑 Flexbox 的原因）。

* * *

1 块布局和内联布局之间的差异超出了本问题的范围，但最突出的是自动宽度：块级框水平拉伸以填充其包含块，而内联级框缩小以适应其包含块内容。事实上，仅出于这个原因，您几乎永远不会使用`display: inline-flex`，除非您有充分的理由内联显示 Flex 容器。

好的，我知道一开始可能有点令人困惑，但是`display`谈论的是父元素，所以意味着当我们说：时`display: flex;`，它是关于元素的，当我们说时`display:inline-flex;`，也是在制作元素本身`inline`......

这就像创建一个`div` **inline**或**block**，运行下面的代码片段，您可以看到如何`display flex`分解到下一行：

    .inline-flex {
      display: inline-flex;
    }
    
    .flex {
      display: flex;
    }
    
    p {
      color: red;
    }

    <body>
      <p>Display Inline Flex</p>
      <div class="inline-flex">
        <header>header</header>
        <nav>nav</nav>
        <aside>aside</aside>
        <main>main</main>
        <footer>footer</footer>
      </div>
    
      <div class="inline-flex">
        <header>header</header>
        <nav>nav</nav>
        <aside>aside</aside>
        <main>main</main>
        <footer>footer</footer>
      </div>
    
      <p>Display Flex</p>
      <div class="flex">
        <header>header</header>
        <nav>nav</nav>
        <aside>aside</aside>
        <main>main</main>
        <footer>footer</footer>
      </div>
    
      <div class="flex">
        <header>header</header>
        <nav>nav</nav>
        <aside>aside</aside>
        <main>main</main>
        <footer>footer</footer>
      </div>
    </body>

运行代码片段Hide results

展开片段

还可以快速创建下面的图像，以一目了然地显示差异：

[![显示柔性与显示内联柔性](https://i.stack.imgur.com/mns2H.jpg)](https://i.stack.imgur.com/mns2H.jpg)

`flex`并且`inline-flex`都将弹性布局应用于容器的子级。容器 with 的`display:flex`行为类似于块级元素本身，而`display:inline-flex`使得容器的行为类似于内联元素。

`display`为了清楚起见，改用二值语法
======================

CSS`display`属性实际上同时设置两件事：外部显示类型和内部显示类型。外部显示类型影响元素（充当容器）在其上下文中的显示方式。内部显示类型影响元素的子元素（或容器的子元素）的布局方式。

如果您使用仅在某些浏览器（如 Firefox）中支持的二值`display`语法，则两者之间的差异更加明显：

*   `display: block`相当于`display: block flow`
*   `display: inline`相当于`display: inline flow`
*   **`display: flex`相当于`display: block flex`**
*   **`display: inline-flex`相当于`display: inline flex`**
*   `display: grid`相当于`display: block grid`
*   `display: inline-grid`相当于`display: inline grid`

外部显示类型：`block`或`inline`：
------------------------

外部显示类型为 的元素`block`将占用其可用的整个宽度，就像`<div>`这样做一样。外部显示类型为 的元素`inline`将仅占用其所需的宽度，就像换行一样`<span>`。

内部显示类型：`flow`、`flex`或`grid`：
----------------------------

当或未指定时，内部显示类型`flow`为默认内部显示类型。这是我们在实例中习惯的布局子元素的方式。这些都是让每个孩子都有自己的位置的新方法。`flex``grid``<p>``flex``grid`

### 结论：

`display: flex`和 的区别`display: inline-flex`在于外部显示类型，第一个的外部显示类型是`block`，第二个的外部显示类型是`inline`。两者的内部显示类型均为`flex`。

### 参考：

*   [](https://hacks.mozilla.org/2019/10/the-two-value-syntax-of-the-css-display-property/)mozzilla.org 上[CSS Display 属性的二值语法](https://hacks.mozilla.org/2019/10/the-two-value-syntax-of-the-css-display-property/)

**“flex”和“inline-flex”之间的区别**

**简短回答：**

一个是内联的，另一个基本上像块元素一样响应（但有一些自己的差异）。

**更长的答案：**

Inline-Flex - Flex 的内联版本允许元素及其子元素具有 Flex 属性，同时仍保留在文档/网页的常规流程中。基本上，如果宽度足够小，您可以将两个内联 Flex 容器放置在同一行中，而无需任何多余的样式来允许它们存在于同一行中。这与“内联块”非常相似。

Flex - 容器及其子容器具有 flex 属性，但容器保留该行，因为它是从文档的正常流程中取出的。就文档流而言，它的响应就像块元素一样。如果没有多余的样式，两个 Flexbox 容器不能存在于同一行。

**您可能遇到的问题**

由于您在示例中列出的元素，尽管我猜测，我认为您希望使用 flex 以均匀的逐行方式显示列出的元素，但继续并排查看元素。

您可能遇到问题的原因是因为 flex 和 inline-flex 将默认的“flex-direction”属性设置为“row”。这将并排显示子项。将此属性更改为“column”将允许您的元素堆叠并保留等于其父级宽度的空间（宽度）。

下面是一些示例，展示了 flex 与 inline-flex 的工作原理，以及内联元素与块元素如何工作的快速演示......

    display: inline-flex; flex-direction: row;
    

[小提琴](http://jsfiddle.net/vUSmV/258/)

    display: flex; flex-direction: row;
    

[小提琴](http://jsfiddle.net/vUSmV/259/)

    display: inline-flex; flex-direction: column;
    

[小提琴](http://jsfiddle.net/vUSmV/260/)

    display: flex; flex-direction: column;
    

[小提琴](http://jsfiddle.net/vUSmV/261/)

    display: inline;
    

[小提琴](https://jsfiddle.net/qzk7y3ka/2/)

    display: block
    

[小提琴](https://jsfiddle.net/6nacd8ch/2/)

另外，还有一个很棒的参考文档： [A Complete Guide to Flexbox - css技巧](https://css-tricks.com/snippets/css/a-guide-to-flexbox/)

CSS 的 display: inline -flex 和 display:flex 有什么区别？

CSS 中的媒体查询选择器主要用于根据不同的媒体类型和条件为页面应用不同的样式规则。在这些选择器中，`screen` 和 `only screen` 是两种常见的用法，它们在功能上有细微的区别。

### `screen`

媒体类型 `screen` 是指针对计算机屏幕、平板电脑、智能手机等屏幕设备的样式。当我们使用媒体查询中的 `screen` 关键字时，意味着所包含的样式只会在媒体类型是屏幕的设备上应用。例如：

```css
@media screen and (max-width: 600px) {
  body {
    background-color: lightblue;
  }
}
```

上面的例子中，背景色 `lightblue` 只会在设备屏幕宽度小于或等于600像素时应用。

### `only screen`

`only screen` 关键字的增加是为了防止老旧的浏览器不正确地解释媒体查询。`only` 关键字用来指定某些样式仅应该被支持媒体查询的浏览器应用，而不是所有设备。在 `screen` 之前添加 `only` 关键字，可以防止不支持CSS媒体查询的浏览器将媒体查询内的样式应用于所有媒体类型。

```css
@media only screen and (max-width: 600px) {
  body {
    background-color: lightblue;
  }
}
```

在这个例子中，使用 `only screen` 相比单独使用 `screen`，对于现代浏览器来说并没有区别，它们都会将背景色应用在屏幕宽度小于或等于600像素的屏幕上。但对于那些不支持CSS媒体查询的老旧浏览器，则不会应用这个样式规则。

总结来说，`screen` 和 `only screen` 的主要区别在于向后兼容性处理。`only` 的添加是为了确保旧版浏览器不会将样式规则应用于不支持的媒体类型，而现代浏览器则可以忽略 `only` 关键字，因为它们已经支持媒体查询。随着现代浏览器的普及，这种差异已经变得不那么重要，但在编写代码时仍需考虑到可能的兼容性问题。

让我们一一分解您的示例。

    @media (max-width:632px)
    

这表示对于`max-width`632px 的窗口，您想要应用这些样式。在大多数情况下，在这种尺寸下，您会谈论任何比桌面屏幕更小的东西。

    @media screen and (max-width:632px)
    

这是说对于具有 的设备`screen`和具有 632px 的窗口`max-width`应用该样式。这与上面的几乎相同，只是您指定的是与[其他可用媒体类型](http://www.w3.org/TR/CSS2/media.html)`screen`相反的 最常见的另一种媒体类型。[](http://www.w3.org/TR/CSS2/media.html)`print`

    @media only screen and (max-width:632px)
    

这里直接引用 W3C 的一段话来解释这一点。

> 关键字“only”也可用于对旧用户代理隐藏样式表。用户代理必须处理以“only”开头的媒体查询，就好像“only”关键字不存在一样。

由于不存在“only”这样的媒体类型，因此旧版浏览器应忽略样式表。

以下是该页面示例 9 中显示的[引用的链接。](http://www.w3.org/TR/css3-mediaqueries/#media0)

希望这能为媒体查询带来一些启发。

编辑：

请务必查看[@hybrids](https://stackoverflow.com/a/14168210/1078110)关于如何`only`真正处理关键字的优秀答案。

以下内容来自[**Adob​​e 文档**](http://www.adobe.com/devnet/dreamweaver/articles/introducing-media-queries.html)。

* * *

媒体查询规范还提供了关键字`only`，其目的是对旧版浏览器隐藏媒体查询。与 一样`not`，关键字必须出现在声明的开头。例如：

    media="only screen and (min-width: 401px) and (max-width: 600px)"
    

无法识别媒体查询的浏览器需要一个以逗号分隔的媒体类型列表，并且规范表示它们**应该**在第一个不是连字符的非字母数字字符之前截断每个值。因此，旧的浏览器**应该**将前面的示例解释为：

    media="only"
    

由于不存在 only 这样的媒体类型，因此样式表将被忽略。同样，旧的浏览器**应该**解释

    media="screen and (min-width: 401px) and (max-width: 600px)"
    

作为

    media="screen"
    

换句话说，它应该将样式规则应用于所有屏幕设备，即使它不知道媒体查询的含义。

**不幸的是，IE 6-8 未能正确实现该规范。**

它不会将样式应用到所有屏幕设备，而是完全忽略样式表。

尽管存在这种行为，但仅当您想对其他不太常见的浏览器隐藏样式时，仍然建议在媒体查询前添加前缀 。

* * *

所以，使用

    media="only screen and (min-width: 401px)"
    

和

    media="screen and (min-width: 401px)"
    

在 IE6-8 中将具有相同的效果：两者都会阻止使用这些样式。但是，它们仍然会被下载。

此外，在支持 CSS3 媒体查询的浏览器中，如果视口宽度大于`401px`且媒体类型为 screen，则两个版本都会加载样式。

我不完全确定哪些不支持 CSS3 媒体查询的浏览器需要该`only`版本

    media="only screen and (min-width: 401px)" 
    

相对于

    media="screen and (min-width: 401px)"
    

确保它不会被解释为

    media="screen"
    

对于能够进入设备实验室的人来说，这将是一个很好的测试。

要为许多屏幕较小的智能手机设计样式，您可以编写：

    @media screen and (max-width:480px) { … } 
    

要阻止旧版浏览器查看 iPhone 或 Android 手机样式表，您可以编写：

    @media only screen and (max-width: 480px;) { … } 
    

阅读本文了解更多信息[http://webdesign.about.com/od/css3/a/css3-media-queries.htm](http://webdesign.about.com/od/css3/a/css3-media-queries.htm)

@hybrid 的答案非常丰富，只是它没有解释 @ashitaka 提到的目的“如果使用移动优先方法会怎样？所以，我们首先使用移动 CSS，然后使用 min-width 来定位更大的网站.我们不应该在这种情况下使用 only 关键字，对吗？”

想要在此处添加，其目的只是为了防止不支持的浏览器使用其他设备样式，就好像它从“屏幕”开始一样，而不会将其视为屏幕，而如果它从“仅”样式开始，则将被忽略。

回答 ashitaka 考虑这个例子

    <link rel="stylesheet" type="text/css" 
      href="android.css" media="only screen and (max-width: 480px)" />
    <link rel="stylesheet" type="text/css" 
      href="desktop.css" media="screen and (min-width: 481px)" />
    

如果我们不使用“only”，它仍然可以工作，因为桌面样式也将使用引人注目的 android 样式，但会产生不必要的开销。在这种情况下，如果浏览器不支持，它将回退到第二个样式表，忽略第一个样式表。

@media screen and (max-width:480px) { … } 
    

`screen`这里是设置媒体查询的屏幕大小。例如显示区域的最大宽度为480px。因此，它指定的是屏幕而不是其他可用的媒体类型。

    @media only screen and (max-width: 480px;) { … } 
    

`only screen` 这里用于防止不支持具有媒体功能的媒体查询的旧浏览器应用指定的样式。

CSS 的媒体查询选择器，screen 和 only screen 有什么区别？

要使用CSS将`div`元素美化成看起来像`a`标签链接的样式，我们可以通过设置`div`的一些基础样式来模拟`a`标签的外观。下面是具体的步骤和一个例子：

1. **颜色和文本装饰**：通常，链接的文本颜色为蓝色，并且有下划线，以便用户可以识别它们。我们可以对`div`应用相同的样式。

2. **鼠标悬停效果**：当鼠标指针悬停在链接上时，链接通常会改变颜色或下划线。我们可以为`div`添加`:hover`伪类来实现这个效果。

3. **光标样式**：为了让用户知道他们可以点击`div`，我们可以将光标样式设置为`pointer`，这通常是链接的标志。

4. **可访问性**：虽然样式上可以模仿链接的外观，但`div`元素默认不具有键盘可访问性和语义性。为了提高可访问性，我们可以使用`tabindex`属性。

5. **交互性**：如果你想让`div`元素像链接那样实际工作，你需要使用JavaScript来监听点击事件，并导航到指定的URL。

下面是一个将`div`元素美化成看起来像`a`标签链接的CSS样式例子：

```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Div as a Link</title>
<style>
  .link-style-div {
    color: blue;
    text-decoration: underline;
    cursor: pointer;
    padding: 10px;
    margin: 5px;
    display: inline-block; /* 可以是其他合适的显示类型，根据布局需求而定 */
  }
  .link-style-div:hover {
    text-decoration: none;
    color: darkblue;
  }
</style>
</head>
<body>

<div class="link-style-div" onclick="window.location.href='http://example.com';" tabindex="0">
  点击这个div跳转到example.com
</div>

<script>
  // 为了更好的可访问性，我们可以加入键盘监听事件
  document.querySelector('.link-style-div').addEventListener('keypress', function(event) {
    if (event.key === 'Enter' || event.key === ' ') {
      window.location.href = 'http://example.com';
    }
  });
</script>

</body>
</html>
```

在上面的代码中，我们创建了一个具有基础链接样式的`div`元素，当用户点击或者按下回车键（Enter）或空格键（Space）时，页面会导航到`http://example.com`。我们通过JavaScript添加了点击和键盘监听事件，以实现`div`的交互性。

来到这里是希望找到一个更好的解决方案，但我不喜欢这里提供的任何解决方案。我认为你们中有些人误解了这个问题。 OP 想让一个充满内容的 div 表现得像一个链接。 Facebook 广告就是一个例子 - 如果你仔细观察，它们实际上是正确的标记。

对我来说，禁忌是： javascript（不应该仅仅为了链接而需要，而且搜索引擎优化/可访问性非常糟糕）；无效的 HTML。

本质上是这样的：

*   使用正常的 CSS 技术和有效的 HTML 构建您的面板。
*   在其中的某个位置放置一个链接，如果用户单击面板，您希望该链接成为默认链接（您也可以有其他链接）。
*   在该链接内，放置一个空的跨度标签（`<span></span>`，而不是`<span />`\- 感谢@Campey）
*   给面板位置：相对
*   将以下 CSS 应用到空范围：
    
        { 
          position:absolute; 
          width:100%;
          height:100%;
          top:0;
          left: 0;
        
          z-index: 1;
        
          /* fixes overlap error in IE7/8, 
             make sure you have an empty gif */
          background-image: url('empty.gif');
        }   
        
    
    它现在将覆盖面板，并且由于它位于`<A>`标签内，因此它是一个可点击的链接
    
*   给面板内的任何其他链接位置：相对和合适的 z-index (>1)，将它们放在默认跨度链接的前面

您无法创建`div`a 链接本身，但可以使`<a>`标记充当 a `block`，与 a 具有相同的行为`<div>`。

    a {
        display: block;
    }
    

然后您可以设置其宽度和高度。

这是一个古老的问题，但我想我会回答它，因为这里的每个人都有一些疯狂的解决方案。其实非常非常简单...

锚标签的工作方式如下 -

    <a href="whatever you want"> EVERYTHING IN HERE TURNS INTO A LINK </a>
    

苏...

    <a href="whatever you want"> <div id="thediv" /> </a>
    

虽然我不确定这是否有效。如果这就是口头解决方案背后的原因，那么我深表歉意......

需要一点 JavaScript。但是，你的`div`将是可点击的。

    <div onclick="location.href='http://www.example.com';" style="cursor:pointer;"></div>

This option doesn’t require an empty.gif as in the most upvoted answer:

HTML:

     <div class="feature">
           <a href="http://www.example.com"></a>
     </div>
    

CSS:

     div.feature {
            position: relative;
        }
    
        div.feature a {
            position: absolute;
            width: 100%;
            height: 100%;
            top: 0;
            left: 0;
            text-decoration: none; /* No underlines on the link */
            z-index: 10; /* Places the link above everything else in the div */
            background-color: #FFF; /* Fix to make div clickable in IE */
            opacity: 0; /* Fix to make div clickable in IE */
            filter: alpha(opacity=1); /* Fix to make div clickable in IE */
        }
    

As proposed at [http://www.digitalskydesign.com/how-to-make-an-entire-div-a-link-using-css/](http://www.digitalskydesign.com/how-to-make-an-entire-div-a-link-using-css/)

CSS 如何将 div 元素美化成 a 标签链接？

`Normalize.css` 和 `Reset.css` 都是CSS工具，旨在提供一致的跨浏览器默认样式。它们的主要目的是消除不同浏览器之间的默认样式差异，从而简化设计师和开发人员的工作。不过，它们在实现这一目标的方法和理念上存在一些差异：

### Normalize.css
- **目标**：Normalize.css 的目标是使浏览器的默认样式更加一致，并保留有用的默认值。而不是去除所有的样式，它会修复浏览器之间的差异，并保持良好的可用性。
- **保留样式**：它保留了有用的默认样式，而不是“抹除”所有样式。例如，`sup` 或 `sub` 元素在不同浏览器中会有不同的渲染方式，normalize.css 会统一这些样式，但保留它们的基本功能。
- **修复浏览器的bug**：它修复了常见的桌面和移动浏览器的bug，如HTML5元素的显示、预格式化文本的显示等。
- **模块化**：通常来说，normalize.css 可以用作模块化的基础，可以在其上添加其他样式。

### Reset.css
- **目标**：Reset.css 的目的是去除所有的浏览器默认样式，为设计提供一个干净的画布。它通过为几乎所有元素提供统一的样式（如margin, padding设为0）来实现这一点。
- **去除样式**：它倾向于“归零”所有的样式，这意味着设计师需要重新定义大量的样式。
- **一致性**：它的核心理念是消除差异，确保所有元素在不同浏览器中看起来是一致的，尽管这样做也涵盖了将有用的默认样式归零。
- **定制需要**：当使用reset.css时，开发者通常需要在其基础上定制大量的CSS规则以获得期望的外观。

### 实际例子
假设你正在处理一个列表元素 `<ul>`：

- 使用 **Reset.css**，所有的 `<ul>` 列表样式（包括内边距和项目符号）都会被移除，你需要手动为每个列表添加样式。
- 使用 **Normalize.css**，默认的列表样式将会被一致化，但基本的项目符号和缩进将会被保留，这意味着你只需要定义具体的列表样式，而不是重新构建整个列表的样式。

在选择使用哪一个的时候，一般会根据项目需求和个人喜好来决定。如果你希望完全控制每一个元素并且乐意从零开始构建你的样式，你可能会倾向于使用Reset.css。如果你希望保留一些默认样式，并且优先考虑跨浏览器的一致性，那么Normalize.css可能是更好的选择。

主要区别是：

1. **Normalize.css** 保留有用的默认值，而不是“取消样式化”所有内容。**例如，诸如 `sup`或 `sub`“正常工作”之类的元素在包含 normalize.css 后（并且实际上变得更加健壮），而在包含 reset.css 后它们在视觉上与普通文本没有区别。因此，normalize.css 不会给您强加视觉起点（同质性）。这可能不符合每个人的口味。最好的办法是尝试两者，看看哪种适合您的喜好。
2. **Normalize.css 纠正了一些超出 Reset.css 范围的常见错误。**`font`它的范围比reset.css更广泛，并且还提供了常见问题的错误修复，例如：HTML5元素的显示设置、表单元素缺乏继承、更正 `font-size`渲染 `pre`、IE9中的SVG溢出以及 `button`iOS中的样式错误。
3. **Normalize.css 不会扰乱您的开发工具。**使用reset.css时，一个常见的问题是浏览器CSS调试工具中显示的大型继承链。由于有针对性的样式，这对于 normalize.css 来说不是一个问题。
4. **Normalize.css 更加模块化。**该项目被分解为相对独立的部分，如果您知道您的网站永远不需要这些部分（例如表单规范化），那么您可以轻松地删除它们。
5. **Normalize.css 有更好的文档。** Normalize.css 代码内联且更全面地记录在[GitHub Wiki](https://github.com/necolas/normalize.css/wiki)中。这意味着您可以找出每行代码的作用、为什么包含它、浏览器之间的差异是什么，并且更轻松地运行您自己的测试。该项目旨在帮助人们了解浏览器默认如何渲染元素，并使他们更容易参与提交改进。

**主要区别在于：**

*   CSS 重置的目的是_删除_所有内置的浏览器样式。 H1-6、p、strong、em 等标准元素最终看起来完全一样，根本没有任何装饰。然后你应该自己添加_所有装饰_。
    
*   [规范化 CSS](http://necolas.github.com/normalize.css/)旨在使内置浏览器样式在各个浏览器之间_保持一致_。像 H1-6 这样的元素将在浏览器中以一致的方式显示为粗体、更大等。然后，您应该仅添加设计所需的装饰_差异。_
    

如果您的设计_a)_遵循排版等的常见约定，并且_b)_ Normalize.css 适用于您的目标受众，那么使用 Normalize.CSS 而不是 CSS 重置将使您自己的 CSS 更小且编写速度更快。

Normalize.css 主要是一组样式，基于其作者认为好看的样式，并使其在浏览器中看起来一致。重置基本上会从元素中剥离样式，以便您可以更好地控制所有内容的样式。

我两者都用。

有些样式来自 Reset，有些来自 Normalize.css。例如，在 Normalize.css 中，有一种样式可确保所有输入元素具有相同的字体，而这种情况不会发生（在文本输入和文本区域之间）。 Reset 没有这样的样式，因此输入具有不同的字体，这通常是不需要的。

从描述来看，它似乎试图使用户代理的默认样式在所有浏览器中保持一致，而不是像重置那样剥离所有默认样式。

> 与许多 CSS 重置不同，保留有用的默认值。

首先`reset.css`是您可以使用的最糟糕的库，因为它删除了 HTML 的标准结构，并在将边距填充和其他属性的值分配给`0`.例如，您会发现`<H1>`, 将与 相同`<H6>`。

另一方面`Normalize.css`使用标准结构并修复了其中存在的几乎所有错误。例如，它解决了从一个浏览器向另一个浏览器显示表单的问题。 Normalize 通过修改此功能来修复此问题，以便您的元素在所有浏览器上显示相同。

Normalize.css 和 Reset CSS 是两种不同的CSS工具，它们的目标都是解决跨浏览器的一致性问题，但它们各自的方法和目的有所不同。

**Reset CSS** 的目的是通过消除浏览器默认的所有样式来提供一个统一的基线。这样做意味着所有的HTML元素开始时都没有装饰，确保了在不同的浏览器中展现的一致性。使用Reset CSS可以使开发者不受浏览器默认样式的干扰，从零开始构建设计。Reset CSS的一个典型代表是Eric Meyer的“Reset CSS”，它移除了边距、内填充、字体大小和其它样式。

例如，Reset CSS可能包含以下规则来移除元素的边距和内填充：

```css
html, body, div, span, applet, object, iframe,
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
a, abbr, acronym, address, big, cite, code,
del, dfn, em, img, ins, kbd, q, s, samp,
small, strike, strong, sub, sup, tt, var,
b, u, i, center,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td,
article, aside, canvas, details, embed, 
figure, figcaption, footer, header, hgroup, 
menu, nav, output, ruby, section, summary,
time, mark, audio, video {
  margin: 0;
  padding: 0;
  border: 0;
  font-size: 100%;
  font: inherit;
  vertical-align: baseline;
}
```

相比之下，**Normalize.css** 采取了不同的方法。其目的是保持浏览器的默认样式，但同时纠正了常见的跨浏览器不一致性和修复了常见的bug。Normalize.css 意在保留有用的默认值，而不是去掉所有的默认值。它也会根据具体的元素微调样式，以确保在不同浏览器中呈现出相似的视觉效果。

例如，Normalize.css 可能包含规则来统一不同浏览器的默认样式，而不是完全去除它们：

```css
article,
aside,
details,
figcaption,
figure,
footer,
header,
hgroup,
main,
nav,
section {
  display: block;
}

body {
  line-height: 1.6;
  font-family: sans-serif;
}

ol,
ul {
  list-style: none;
}
```

总而言之，Reset CSS是为了从一个完全一致的空白画布开始，而Normalize.css是为了在不同浏览器之间保持一致性的同时保留有用的默认样式。选择使用哪一个工具取决于你的项目需求和个人偏好。

Normalize css 和 Reset css 之间的区别是什么？

在CSS中，`border: none`和`border: 0`都可以用来移除元素的边框，但它们在语义上有轻微的差别。

`border: none`意味着没有边框，即边框的样式设为"none"，这表明不显示边框；而`border: 0`将边框的宽度设置为0，这在效果上也会导致边框不显示，但语义上侧重于宽度。

对于大多数浏览器来说，这两种方式都会移除元素的边框，看起来没有差别。但是，`border: none`在某些情况下可能会有更好的可读性，因为它直接说明了边框是不存在的，而`border: 0`需要读者理解宽度为0意味着边框不会显示。

从实用角度来说，使用`border: none`可能会更清晰地表达你的意图，这在团队合作和维护代码时是有益的。

举例来说，如果你正在处理一个按钮组件，你可能会这样设定它的样式，以确保在所有情况下按钮看起来都没有边框：

```css
.button {
  border: none;
  /* 其他样式 */
}
```

这样，无论何时别人阅读这段代码，都能很直观地理解边框是不应该展现的。

总结来说，在大多数情况下，`border: none`和`border: 0`可以互换使用。然而，`border: none`可能在语义上更清晰一些，因此如果不涉及性能优化等其他因素，推荐使用`border: none`来提高代码的可读性。

**两者都有效。**这是你的选择。

我更喜欢，`border:0`因为它更短；我发现这样更容易阅读。您可能会发现`none`更清晰。我们生活在一个拥有非常强大的 CSS 后处理器的世界，所以我建议您使用您喜欢的任何东西，然后通过“压缩器”运行它。这里没有值得打的圣战，但 Webpack → LESS → PostCSS → PurgeCSS 是一个很好的 2020 年堆栈。

话虽如此，如果您手写所有的生产 CSS，我认为（尽管评论中有抱怨）**关注带宽并没有什么坏处**。使用它本身`border:0` _会节省极少量的带宽，但如果您__充分利用每个字节_，您将使您的网站更快。

* * *

CSS2 规范[在这里](http://www.w3.org/TR/CSS2/box.html#propdef-border)。这些在 CSS3 中得到了扩展，但与此没有任何关系。

    'border'
        Value:      [ <border-width> || <border-style> || <'border-top-color'> ] | inherit
        Initial:    see individual properties
        Applies to:     all elements
        Inherited:      no
        Percentages:    N/A
        Media:      visual
        Computed value:     see individual properties 
    

您可以使用宽度、样式和颜色的任意组合。  
在这里， `0`设置宽度、`none`样式。它们具有相同的渲染结果：没有显示任何内容。

它们实际上是等效的_，_指向[不同的快捷方式](http://www.w3schools.com/css/css_border.asp)：

    border: 0;
    //short for..
    border-width: 0;
    

和另一个..

    border: none;
    //short for...
    border-style: none;
    

两者都有效，只需选择一个即可使用:)

（注：此答案已于2014-08-01更新，使其更详细、更准确，并添加了[现场演示](http://codepen.io/denilsonsa/pen/LkdHh?editors=110)）

扩展shortand属性
------------

根据[W3C CSS2.1 规范](http://www.w3.org/TR/CSS21/box.html#border-shorthand-properties)（_“省略的值设置为其初始值”_），以下属性是等效的：

    border: hidden;    border-style: hidden;
                       border-width: medium;
                       border-color: <the same as 'color' property>
    
    border: none;      border-style: none;
                       border-width: medium;
                       border-color: <the same as 'color' property>
    
    border: 0;         border-style: none;
                       border-width: 0;
                       border-color: <the same as 'color' property>
    

如果这些规则是应用于元素边框的最具体的规则，则不会显示边框，要么是因为零宽度，要么是因为`hidden`/`none`样式。因此，乍一看，这三个规则看起来是等效的。然而，当它们与其他规则结合使用时，它们的行为方式会有所不同。

折叠边框模型中表格上下文中的边框
----------------

当使用 渲染表格时`border-collapse: collapse`，每个渲染的边框在多个元素之间共享（内部边框在相邻单元格之间共享；外部边框在单元格和表格本身之间共享；而且行、行组、列和列组也共享边框） ）。该规范定义了一些[边界冲突解决规则](http://www.w3.org/TR/CSS21/tables.html#border-conflict-resolution)：

> 1.  `border-style`与的边界`hidden`优先于所有其他冲突边界。 \[…\]
>     
> 2.  样式为 的边框`none`优先级最低。 \[…\]
>     
> 3.  如果没有一种样式是 ，`hidden`并且至少有一种样式不是`none`，那么窄边框将被丢弃，转而使用更宽的边框。 \[…\]
>     
> 4.  如果边框样式仅颜色不同，\[...\]
>     

因此，在表上下文中，`border: hidden`(或`border-style: hidden`) 将具有最高优先级，并且无论如何都会隐藏共享边框。

在优先级的另一端，`border: none`(或`border-style: none`) 具有最低优先级，其次是零宽度边框（因为它是最窄的边框）。这意味着 的**计算值**和`border-style: none`的**计算值**本质`border-width: 0`上是相同的。

级联规则和继承
-------

由于`none`和`0`影响不同的属性（`border-style`和`border-width`），因此当[更具体的规则](http://www.w3.org/TR/CSS2/cascade.html#specificity)仅定义样式或仅定义宽度时，它们的行为会有所不同。请参阅[克里斯的回答](https://stackoverflow.com/a/2948616/)作为示例。

[现场演示](http://codepen.io/denilsonsa/pen/LkdHh?editors=110)！
-----------------------------------------------------------

想要在一页中查看所有这些案例吗？打开**[现场演示](http://codepen.io/denilsonsa/pen/LkdHh?editors=110)**！

正如其他人所说，两者都是有效的并且都会起作用。但我并不 100% 相信它们是相同的。如果您正在进行某种样式级联，那么理论上它们可能会产生不同的结果，因为它们实际上覆盖了不同的值。

例如。如果设置“边框：无；”然后使用两种不同的样式来覆盖边框宽度和样式，然后一种会执行某些操作，而另一种则不会。

在下面的 IE 和 Firefox 示例中，前两个测试 div 没有边框。然而，第二个 div 不同，第二个块中的第一个 div 是普通的，第二个块中的第二个 div 具有中等宽度的虚线边框。

因此，尽管它们都是有效的，但如果它们像我认为的那样进行大量级联，您可能需要留意您的样式。

    <html>
    <head>
    <style>
    div {border: 1px solid black; margin: 1em;}
    .zerotest div {border: 0;}
    .nonetest div {border: none;}
    
    div.setwidth {border-width: 3px;}
    div.setstyle {border-style: dashed;}
    
    </style>
    </head>
    <body>
    
    <div class="zerotest">
    <div class="setwidth">
    "Border: 0" and "border-width: 3px"
    </div>
    <div class="setstyle">
    "Border: 0" and "border-style: dashed"
    </div>
    </div>
    
    <div class="nonetest">
    <div class="setwidth">
    "Border: none" and "border-width: 3px"
    </div>
    <div class="setstyle">
    "Border: none" and "border-style: dashed"
    </div>
    </div>
    
    </body>
    </html>

使用

    border: none;
    

在某些版本的 IE 中不起作用。 IE9 很好，但在以前的版本中，即使样式为“none”，它也会显示边框。我在使用打印样式表时遇到过这种情况，我不希望输入框上有边框。

    border: 0;
    

似乎在所有浏览器中都能正常工作。

CSS 中 border:none 和 border:0 应该使用哪个？

`display: inline` 和 `display: inline-block` 都是CSS中的显示属性，它们定义了元素如何在页面上布局，但是它们之间有一些关键的区别：

1. **框模型**：
   - `display: inline`：元素不会开始一个新的块级上下文，元素按照内联（水平）方向排列，处于同一行内。内联元素不会考虑上下margin和padding设置影响布局，且不允许设置宽度和高度。
   - `display: inline-block`：兼有inline和block元素的特点。它排列在同一行内，但是像块级元素一样，允许设置元素的宽度和高度。

2. **布局控制**：
   - `display: inline`：因为无法设置宽高，所以对于布局控制有一定限制。通常用于不需要宽高控制的小元素，比如文字或者链接。
   - `display: inline-block`：可以设置宽度和高度，因此提供了更好的布局控制，适合需要特定大小但又希望在文本流中显示的元素。

3. **元素对齐**：
   - `display: inline`：元素的垂直对齐受到 `vertical-align` 属性影响，通常是以基线对齐。
   - `display: inline-block`：元素虽然在一行显示，但可以像块级元素一样处理垂直对齐，使用 `vertical-align` 属性可以调整与其他行内元素的对齐方式。

### 示例
- **`display: inline` 示例**：假设你有一系列的链接，你想让它们在一行内显示，而不打断文本的流动。
   ```html
   <a href="#">Home</a>
   <a href="#">About</a>
   <a href="#">Contact</a>
   ```
   这些链接默认就是内联元素，它们会从左到右在一行内显示，除非行没有足够的空间。

- **`display: inline-block` 示例**：如果你有一组小的卡片，比如用户的头像，并希望它们在一行内显示，但又想控制每张卡片的大小。
   ```html
   <div class="user-avatar">Alice</div>
   <div class="user-avatar">Bob</div>
   <div class="user-avatar">Charlie</div>
   ```
   ```css
   .user-avatar {
     display: inline-block;
     width: 50px;
     height: 50px;
     margin: 5px;
   }
   ```
   每个 `.user-avatar` 元素会在一行内显示，但你可以控制它们的大小和边距，从而创建一个均匀的卡片布局，而不是简单的文本链接。

总结来说，如果你需要在同一行内显示元素，并对元素的大小和布局有更精细的控制，`display: inline-block` 是一个不错的选择。如果你只是需要简单的内联元素，不需要设置宽度和高度，`display: inline` 就足够了。

视觉答案
====

想象一下 中的一个`<span>`元素`<div>`。`<span>`例如，如果给元素设置 100px 的高度和红色边框，它看起来会像这样

**显示方式： 内嵌**

![显示方式： 内嵌](https://i.stack.imgur.com/Emf0B.png)

**显示：内联块**

![显示：内联块](https://i.stack.imgur.com/1vbks.png)

**显示：块**

![在此输入图像描述](https://i.stack.imgur.com/IPf9Q.png)

代码： http: [//jsfiddle.net/Mta2b/](http://jsfiddle.net/Mta2b/)

的元素与元素`display:inline-block`相似`display:inline`，但它们可以具有**宽度**和**高度**。这意味着您可以将内联块元素用作块，同时将其在文本或其他元素中流动。

支持样式的差异总结：

*   **内联**：仅`margin-left`, `margin-right`, `padding-left`,`padding-right`
*   **内联块**: `margin`, `padding`, `height`,`width`

`display: inline;`是在句子中使用的显示模式。例如，如果您有一个段落并想要突出显示一个单词，您可以执行以下操作：

    <p>
        Pellentesque habitant morbi <em>tristique</em> senectus
        et netus et malesuada fames ac turpis egestas.
    </p>
    

该`<em>`元素`display: inline;`默认有一个，因为这个标签总是在句子中使用。该元素默认`<p>`有一个，因为它既不是一个句子，也不是在一个句子中，它是一个句子块。`display: block;`

元素`display: inline;` _不能_有 a`height`或 a`width`或垂直`margin`。元素`display: block;` _可以_有`width`,`height`和`margin`。  
如果要给元素添加a `height`，`<em>`则需要将此元素设置为`display: inline-block;`。现在，您可以将 a 添加`height`到元素和所有其他块样式（ 的`block`部分`inline-block`），但它被放置在句子中（ 的`inline`部分`inline-block`）。

答案中没有提到的一件事是内联元素可以在行之间中断，而内联块不能（并且显然会阻止）！因此，内联元素对于设置文本句子和其中的块的样式很有用，但由于它们无法填充，因此您可以使用**行高**来代替。

    <div style="width: 350px">
      Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
      <div style="display: inline; background: #F00; color: #FFF">
        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
      </div>
      Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
    </div>
    <hr/>
    <div style="width: 350px">
      Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
      <div style="display: inline-block; background: #F00; color: #FFF">
        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
      </div>
      Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
    </div>

运行代码片段Hide results

展开片段

[![在此输入图像描述](https://i.stack.imgur.com/xXdn3.png)](https://i.stack.imgur.com/xXdn3.png)

上述所有答案都提供了有关原始问题的重要信息。然而，有一个概括似乎是错误的。

**可以**将宽度和高度设置为至少一个内联元素（我能想到的） - 元素[`<img>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img)。

这里和[这个重复的](https://stackoverflow.com/questions/9189810/css-display-inline-vs-inline-block?answertab=active#tab-top)两个接受的答案都表明这是不可能的，但这似乎不是一个有效的一般规则。

例子：

    img {
      width: 200px;
      height: 200px;
      border: 1px solid red;
    }

    <img src="#" />

运行代码片段Hide results

展开片段

has ，但其和已成功设置`img`。`display: inline``width``height`

[splattne 的答案](https://stackoverflow.com/a/14033814/2164304)可能涵盖了大部分内容，所以我不会重复同样的事情，但是：`inline`并且CSS 属性的`inline-block`行为有所不同`direction`。

在下一个片段中，您会看到`one two`（按顺序）呈现，就像在 LTR 布局中一样。我怀疑这里的浏览器自动将英文部分检测为 LTR 文本并从左到右呈现。

    body {
      text-align: right;
      direction: rtl;
    }
    
    h2 {
      display: block; /* just being explicit */
    }
    
    span {
      display: inline;
    }

    <h2>
      هذا عنوان طويل
      <span>one</span>
      <span>two</span>
    </h2>

运行代码片段Hide results

展开片段

但是，如果我继续设置`display`为`inline-block`，浏览器似乎会尊重该`direction`属性并按顺序从右到左渲染元素，以便`two one`渲染。

    body {
      text-align: right;
      direction: rtl;
    }
    
    h2 {
      display: block; /* just being explicit */
    }
    
    span {
      display: inline-block;
    }

    <h2>
      هذا عنوان طويل
      <span>one</span>
      <span>two</span>
    </h2>

运行代码片段Hide results

展开片段

我不知道这是否还有其他怪癖，我只是在 Chrome 上凭经验发现了这一点。

CSS 中 display inline 和 display inline block 之间的区别是什么？

CSS 是用于控制网页的样式和布局的语言，它不直接修改 HTML 元素的属性，比如 `img` 标签的 `src` 属性。`src` 属性决定了图像标签所引用的图片的路径，是一个 HTML 属性，而不是一个样式属性。

但是，您可以使用 CSS 来控制图片的显示方式，比如通过 `background-image` 属性来设置一个元素的背景图片。例如：

```css
div.backgroundImage {
  width: 100px;
  height: 100px;
  background-image: url('image.jpg');
  background-size: cover;
  background-position: center;
}
```

在上述代码中，我们创建了一个 `div` 元素，然后通过 CSS 为它设置了背景图片。这种方法允许您使用 CSS 控制图像的呈现，但实际的图片仍然需要通过 HTML 或者动态地通过 JavaScript 来引入。例如，您可以使用 JavaScript 来改变 `img` 标签的 `src` 属性：

```javascript
document.getElementById('myImage').src = 'newImage.jpg';
```

在这个例子中，我们通过 JavaScript 选择了一个具有 `id` `myImage` 的 `img` 元素，并且改变了它的 `src` 属性，从而更改了显示的图片。

使用[`content:url("image.jpg")`](https://developer.mozilla.org/en-US/docs/Web/CSS/content)。

完整的工作解决方案（[Live Demo](http://jsfiddle.net/3BRN7/406/)）：

    <!doctype html>
    
    <style>
    .MyClass123{
        content:url("http://imgur.com/SZ8Cm.jpg");
    }
    </style>
    
    <img class="MyClass123"/>

运行代码片段Hide results

展开片段

已测试并工作：

*   铬 14.0.835.163
*   Safari 4.0.5
*   歌剧10.6
*   Firefox 100 及更高版本

已测试但**不起作用**：

*   FireFox 40.0.2（观察Developer Network Tools，可以看到URL加载了，但是图像没有显示）
*   Internet Explorer 11.0.9600.17905（URL 从不加载）

我今天找到了一个解决方案（适用于 IE6+、FF、Opera、Chrome）：

    <img src='willbehidden.png' 
     style="width:0px; height:0px; padding: 8px; background: url(newimage.png);">
    

怎么运行的：

*   图像被缩小，直到宽度和高度不再可见。
*   然后，您需要使用填充来“重置”图像大小。该图像给出了 16x16 的图像。当然，您可以使用 padding-left / padding-top 来制作矩形图像。
*   最后，使用背景将新图像放在那里。
*   如果新的背景图像太大或太小，我建议使用`background-size`例如：`background-size:cover;`将您的图像适合分配的空间。

它也适用于提交输入图像，它们保持可点击状态。

查看现场演示：[http://www.audenaerde.org/csstricks.html#imagereplacecss](http://www.audenaerde.org/csstricks.html#imagereplacecss)

享受！

从 CSS 设置图像的可能方法的集合
------------------

* * *

**CSS2**的[`:after`](http://www.w3.org/TR/CSS2/generate.html#before-after-content)伪元素或**CSS3**的[较新](http://www.w3.org/TR/css3-selectors/#pseudo-elements)语法以及属性：[`::after`](http://www.w3.org/TR/css3-selectors/#gen-content)[`content:`](http://www.w3.org/TR/CSS2/generate.html#content)

第一个 W3C 建议：[层叠样式表，2 级 CSS2 规范](http://www.w3.org/TR/1998/REC-CSS2-19980512/) **1998 年 5 月 12 日**  
最新 W3C 建议：[选择器 3 级 W3C 建议](http://www.w3.org/TR/css3-selectors/) **2011 年 9 月 29 日**

此方法将内容_**附加**_到元素的文档树内容_之后。_

注意：某些浏览器_实验性地_`content`直接在_某些_元素选择器上呈现属性，甚至不顾最新的 W3C 建议定义：

> 适用于：`:before`和`:after`伪元素

CSS2 语法（向前兼容）：

    .myClass:after {
      content: url("somepicture.jpg");
    }
    

CSS3 选择器：

    .myClass::after {
      content: url("somepicture.jpg");
    }
    

默认渲染：**原始大小**（不依赖于显式大小声明）

> 本规范没有完全定义 :before 和 :after 与替换元素（例如 HTML 中的 IMG）的交互。这将在未来的规范中更详细地定义。

但即使在撰写本文时，标签的行为`<IMG>`仍然没有定义，尽管它可以以[黑客和不符合标准的方式](http://jsfiddle.net/7kyg38bs/)使用，_**但不建议**__**使用`<img>`**_！

很棒的候选方法，请参阅结论...

* * *

* * *

\*\*CSS1\*\* 的 \[\`background-image:\`\](http://www.w3.org/TR/REC-CSS1-961217#background-image) 属性：

第一个 W3C 建议：[层叠样式表，第 1 级](http://www.w3.org/TR/REC-CSS1-961217) **1996 年 12 月 17 日**

> 该属性设置元素的背景图像。设置背景图像时，还应该设置一种背景颜色，当图像不可用时将使用该背景颜色。当图像可用时，它将覆盖在背景颜色之上。

这个属性从 CSS 诞生之初就已经存在，但仍然值得一提。

默认渲染：**原始大小**（无法缩放，只能定位）

_然而_，

**CSS3**的[`background-size:`](http://www.w3.org/TR/css3-background/#the-background-size)属性通过允许多个缩放选项进行了改进：

最新 W3C 状态：_候选推荐_ [CSS 背景和边框模块第 3 级](http://www.w3.org/TR/css3-background/) **2014 年 9 月 9 日**

> `[length> | <percentage> | auto ]{1,2} | cover | contain`

但即使有这个属性，它也取决于容器的大小。

仍然是一个不错的候选方法，请参阅结论...

* * *

* * *

**CSS2**的[`list-style:`](http://www.w3.org/TR/CSS2/generate.html#propdef-list-style)属性以及`display: list-item`：

第一个 W3C 建议：[层叠样式表，2 级 CSS2 规范](http://www.w3.org/TR/1998/REC-CSS2-19980512/) **1998 年 5 月 12 日**

`list-style-image:`属性设置将用作列表项标记（项目符号）的图像

> 列表属性描述列表的基本视觉格式：它们允许样式表指定标记类型（**图像**、字形或数字）

`display: list-item`— 该值导致元素（例如，**`<li>`**在 HTML 中）生成主块框和标记框。

    .myClass {
        display: list-item;
        list-style-position: inside;
        list-style-image: url("someimage.jpg");
    }
    

CSS 简写：( `<list-style-type> <list-style-position> <list-style-image>`)

    .myClass {
        display: list-item;
        list-style: square inside url("someimage.jpg");
    }
    

默认渲染：**原始大小**（不依赖于显式大小声明）

限制：

\-

> 继承会将“列表样式”值从 OL 和 UL 元素转移到 LI 元素。这是指定列表样式信息的推荐方法。

> 它们不允许作者为列表标记指定不同的样式（颜色、字体、**对齐方式等）或调整其****位置**

此方法也不适合标记`<img>`，因为无法在元素类型之间进行转换，并且这是在 Chrome 上不起作用的[有限的、不合规的 hack 。](http://jsfiddle.net/3BRN7/552/)

好的候选方法，看结论...

* * *

* * *

**CSS3**的[`border-image:`](http://www.w3.org/TR/css3-background/#border-images)属性_推荐_：

最新 W3C 状态：_候选推荐_ [CSS 背景和边框模块第 3 级](http://www.w3.org/TR/css3-background/) **2014 年 9 月 9 日**

背景_类型_方法依赖于以相当特殊的方式指定尺寸_（未为此用例定义）和__到目前为止的_后备边框属性（例如`border: solid`）：

> 请注意，即使它们永远不会导致滚动机制，起始图像仍可能被祖先或视口剪切。

此示例说明图像仅作为右下角_**装饰**__组成_：

    .myClass {
        border: solid;
        border-width: 0 480px 320px 0;
        border-image: url("http://i.imgur.com/uKnMvyp.jpg") 0 100% 100% 0;
    }
    

> 适用于：除内部表元素外的所有元素`border-collapse: collapse`

它仍然不能_改变_' `<img>`s 标签`src`（但[这里有一个 hack](http://jsfiddle.net/d2vuftjv/)），相反我们可以装饰它：

显示代码片段

    .myClass {
        border: solid;
        border-width: 0 96px 96px 0;
        border-image: url("http://upload.wikimedia.org/wikipedia/commons/9/95/Christmas_bell_icon_1.png") 
                      0 100% 100% 0;
    }

    <img width="300" height="120" 
         src="http://fc03.deviantart.net/fs71/f/2012/253/b/0/merry_christmas_card_by_designworldwide-d5e9746.jpg" 
         class="myClass"

Run code snippetHide results

Expand snippet

标准传播后要考虑的良好候选方法。

* * *

* * *

**CSS3**的[`element()`](http://www.w3.org/TR/css4-images/#element-notation)符号_工作草案_也值得一提：

> 注意：该`element()`函数仅再现引用元素的_外观_，而不是实际内容及其结构。

    <div id="img1"></div>
    
    <img id="pic1" src="http://i.imgur.com/uKnMvyp.jpg" class="hide" alt="wolf">
    <img id="pic2" src="http://i.imgur.com/TOUfCfL.jpg" class="hide" alt="cat">
    

我们将使用两个_隐藏图像_之一的_渲染内容_，通过 CSS 根据ID_**选择器**_更改图像_背景_：`#img1`

    #img1 {
        width: 480px; 
        height: 320px; 
        background: -moz-element(#pic1) no-repeat;
        background-size: 100% 100%;
    }
    
    .hide {display: none}
    

注意：它是_**实验性的**_，仅适用于`-moz`Firefox 中的前缀，并且仅适用于 over`background`或`background-image`属性，还需要指定大小。

*   [element() 现场演示](http://jsfiddle.net/gpjmt7s6/)

* * *

结论
==

1.  任何语义内容或结构信息都以 HTML 形式存在。
2.  样式和表现信息位于 CSS 中。
3.  出于 SEO 目的，请勿在 CSS 中_隐藏_有意义的图像。
4.  打印时背景图形通常被禁用。
5.  [](https://wiki.whatwg.org/wiki/Custom_Tags_Analysis)可以使用[自定义标签并通过 CSS 设置样式，但](https://wiki.whatwg.org/wiki/Custom_Tags_Analysis)_原始_版本的 Internet Explorer 无法理解\]（ IE 无法在没有 Javascript 或 CSS_指导的情况下_[设置 HTML5 标签样式（使用 shiv）](https://stackoverflow.com/questions/6602758/ie-not-styling-html5-tags-with-shiv) ） 。
6.  SPA（单页应用程序）根据设计，通常在背景中包含图像

话虽如此，让我们探索一下适合图像显示的 HTML 标签：

### 元素[`<li>`](https://html.spec.whatwg.org/multipage/semantics.html#the-li-element)\[HTML4.01+\]

**`list-style-image`**with方法的完美用例`display: list-item`。

该`<li>`元素可以为空，允许[流动内容](https://html.spec.whatwg.org/multipage/dom.html#flow-content-2)，甚至允许省略`</li>`结束标记。

显示代码片段

    .bulletPics > li {display: list-item}
    #img1 {list-style: square inside url("http://upload.wikimedia.org/wikipedia/commons/4/4d/Nuvola_erotic.png")}
    #img2 {list-style: square inside url("http://upload.wikimedia.org/wikipedia/commons/7/74/Globe_icon_2014-06-26_22-09.png")}
    #img3 {list-style: square inside url("http://upload.wikimedia.org/wikipedia/commons/c/c4/Kiwi_fruit.jpg")}

    <ul class="bulletPics">
        <li id="img1">movie</li>
        <li id="img2">earth</li>
        <li id="img3">kiwi</li>
    </ul>

Run code snippetHide results

Expand snippet

限制：难以设计（`width:`或`float:`可能有帮助）

### 元素[`<figure>`](https://www.w3.org/wiki/HTML/Elements/figure)\[HTML5+\]

> 图元素表示一些流程内容，可选地带有标题，它是独立的（如完整的句子），并且通常作为文档主流程中的单个单元进行引用。

该元素有效，没有内容，但建议包含`<figcaption>`.

> 因此，该元素可用于注释_**插图、图表、照片**_、代码列表等。

默认渲染：元素右对齐，左右填充！

*   [图现场演示](http://jsfiddle.net/3BRN7/542/)

### 元素[`<object>`](http://www.w3.org/TR/html4/struct/objects.html)\[HTML4+\]

> 要包含图像，作者可以使用 OBJECT 元素或 IMG 元素。

该`data`属性是必需的，并且可以具有有效的[MIME 类型](https://www.rfc-editor.org/rfc/rfc7231#section-3.1.1.1)作为值！

    <object data="data:x-image/x,"></object>
    

注意：使用`<object>`CSS 标签的一个技巧是设置一个 _自定义的_有效 MimeType `x-image/x`，后跟无数据（值在所需的逗号后没有数据`,`）

默认渲染：300 x 150px，但可以在 HTML 或 CSS 中指定大小。

*   [对象现场演示](http://jsfiddle.net/3BRN7/546/)

### 标签[`<SVG>`](https://developer.mozilla.org/en/docs/SVG_In_HTML_Introduction)\_

需要[支持 SVG 的浏览器](http://caniuse.com/#feat=svg)并具有 [`<image>`](http://www.w3.org/TR/SVG/struct.html#ImageElement)用于光栅图像的元素

*   [SVG 现场演示](http://jsfiddle.net/zzgum41k/)

### 元素[`<canvas>`](http://www.w3.org/TR/html5/)\[HTML5+\]。

> 该`width`属性默认为**300**，该`height`属性默认为**150**。

*   [画布现场演示](http://jsfiddle.net/9czfoosk/)

### 该`<input>`元素与`type="image"`

限制：

> ...该元素应显示为类似按钮，以表明该元素是一个按钮。

当没有文本时，Chrome 会跟随并渲染一个 4x4px 的空方块

部分解，设置`value=" "`：

    <input type="image" id="img1" value=" ">
    

*   [输入类型=图像现场演示](http://jsfiddle.net/jhm4y7da/1/)

* * *

还要注意**HTML5.1**[`<picture>`](http://www.w3.org/TR/html51/semantics.html#the-picture-element)中即将推出的元素，目前是一个_工作草案_。

我使用了空的 div 解决方案，带有以下 CSS：

    #throbber {
        background-image: url(/Content/pictures/ajax-loader.gif);
        background-repeat: no-repeat;
        width: 48px;
        height: 48px;
        min-width: 48px;
        min-height: 48px;
    }
    

HTML：

    <div id="throbber"></div>

我找到了比建议的解决方案更好的方法，但它确实使用了背景图像。 _兼容方法（无法确认 IE6）_ 来源： http: [//www.kryogenix.org/code/browser/lir/](http://www.kryogenix.org/code/browser/lir/)

    <img src="pathTo/myImage.jpg"/>
    

CSS：

    img[src*="pathTo/myImage.jpg"] {
    
        background-image: url("mynewimg.jpg"); /* lets say 20x20 */
        width: 20px;
    
        display:inline-block;
        padding: 20px 0 0 0;
        height: 0px !important;
    
        /* for IE 5.5's bad box model */
        height /**/:20px;
    }
    

看不到旧图像，按预期看到新图像。

  
_以下简洁的解决方案仅适用于 webkit_

    img[src*="pathTo/myImage.jpg"] {
    
        /* note :) */
        content:'';
        display:inline-block;
    
        width: 20px;
        height: 20px;
        background-image: url("mynewimg.jpg"); /* lets say 20x20 */
    
    }

CSS 是否可以设置 img 标签的 src 属性?

在React中，向同一个元素节点添加多个CSS类可以通过以下几种常见的方法来实现：

### 使用字符串拼接

最简单直接的方法是将多个类名作为字符串拼接起来，然后将这个字符串赋值给元素的`className`属性。比如：

```jsx
function MyComponent() {
  return <div className="class1 class2 class3">Hello, world!</div>;
}
```

如果类名是动态计算的，你可以这样操作：

```jsx
function MyComponent({ isActive, isDisabled }) {
  const classes = `base-class ${isActive ? 'active' : ''} ${isDisabled ? 'disabled' : ''}`;
  return <div className={classes}>Content</div>;
}
```

### 使用数组和`join`方法

如果类名是动态的或者由多个条件控制，可以使用数组来收集所有需要应用的类名，然后使用`join`方法将数组转换成一个以空格分隔的字符串：

```jsx
function MyComponent({ isActive, isDisabled }) {
  const classList = ['base-class'];

  if (isActive) {
    classList.push('active');
  }

  if (isDisabled) {
    classList.push('disabled');
  }

  const className = classList.join(' ');
  return <div className={className}>Content</div>;
}
```

### 使用模板字符串

ES6引入了模板字符串，这使得在字符串中插入变量或者表达式变得更加方便。模板字符串使用反引号（\`）来包围字符串，并用`${}`来嵌入变量或表达式：

```jsx
function MyComponent({ isActive, isDisabled }) {
  const className = `base-class ${isActive ? 'active' : ''} ${isDisabled ? 'disabled' : ''}`;
  return <div className={className}>Content</div>;
}
```

### 使用第三方库

存在一些第三方库可以简化类名的条件组合，比如`classnames`库，该库可以在组件中非常方便地处理动态类名。使用`classnames`库时，你可以这样写：

```jsx
import classNames from 'classnames';

function MyComponent({ isActive, isDisabled }) {
  const className = classNames({
    'base-class': true,
    'active': isActive,
    'disabled': isDisabled
  });

  return <div className={className}>Content</div>;
}
```

以上就是在React中为同一个元素节点添加多个类名的几种常见方法。这些方法可以根据实际项目的需求和个人偏好选择使用。

我使用`ES6` [模板文字](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals)。例如：

    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'}`} />

当需要相当多的逻辑来决定使用（不）使用类时，我使用[类名](https://github.com/JedWatson/classnames)。一个**过于简单的例子**：

    ...
        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'} />

康卡特
---

无需花哨，我正在使用 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}`}>
    

（为了清晰起见进行了编辑）

ReactJS 如何在同一个元素节点添加多个CSS class类？

在HTML页面中，如果用户的浏览器禁用了JavaScript，你可以使用 `<noscript>`标签来显示一条替代性的信息。例如：

```html
<!DOCTYPE html>
<html>
<head>
    <title>检测JavaScript是否启用</title>
</head>
<body>
    
    <script type="text/javascript">
        document.write("JavaScript已经被启用！");
    </script>
    
    <noscript>
        <p>JavaScript被禁用了。本网站的某些功能可能无法正常工作，请启用JavaScript。</p>
        // 或者  
        <meta http-equiv="refresh" content="0; url=whatyouwant.html" />
    </noscript>
</body>
</html>
```

上面的例子展示了当JavaScript被禁用时，页面会展示 `<noscript>`标签里面的内容。如果JavaScript是启用的，`<script>`标签内的代码会被执行，并且页面会显示“JavaScript已经被启用！”的消息。

请注意，使用 `<noscript>`标签只是一种给用户提示信息的简单方式，并不是一种程序化的检测方法。如果你需要在服务器端检测JavaScript是否被禁用，通常需要使用不依赖于JavaScript的后备方法，比如通过表单提交来判断，因为没有JavaScript支持，异步的JavaScript请求（例如使用Ajax）将不会发生，只能依靠传统的同步请求。

我想在这里添加我的 .02。它不是 100% 防弹，但我认为它已经足够好了。

对我来说，首选的例子是发布某种“如果没有 Javascript，这个网站就不能正常工作”的消息，问题是您需要确保您的网站在没有 Javascript 的情况下也能正常工作。一旦你开始走这条路，你就会开始意识到网站应该是防弹的，并且关闭 JS，这是一大堆额外的工作。

所以，你真正想要的是“重定向”到一个页面，上面写着“打开 JS，傻瓜”。但是，当然，您无法可靠地进行元重定向。所以，这是建议：

    <noscript>
        <style type="text/css">
            .pagecontainer {display:none;}
        </style>
        <div class="noscriptmsg">
        You don't have javascript enabled.  Good luck with that.
        </div>
    </noscript>
    

...您网站中的_所有_内容都用“pagecontainer”类的 div 进行包装。 noscript 标签内的 CSS 将隐藏所有页面内容，并显示您想要显示的任何“no JS”消息。这实际上就是 Gmail 所做的……如果它对 Google 来说足够好，那么对我的小网站来说也足够好。

我假设您正在尝试决定是否提供 JavaScript 增强内容。最好的实现会彻底降级，以便网站在没有 JavaScript 的情况下仍然可以运行。我还假设您指的是[服务器端](https://www.seguetech.com/client-server-side-code/ "“客户端与服务器端代码：有什么区别？”")检测，而不是[`<noscript>`](https://www.w3.org/TR/html52/semantics-scripting.html#the-noscript-element "WC3 建议：<noscript> 元素 (HTML 5.2)")出于无法解释的原因使用该元素。

没有好的方法来执行服务器端 JavaScript 检测。作为替代方案，可以[使用 JavaScript 设置 cookie](https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie "MDN：文档.cookie")，然后在后续页面视图中使用服务器端脚本测试该 cookie。然而，这不适合决定要传送什么内容，因为它无法将没有 cookie 的访问者与新访问者或不接受 JavaScript 设置 cookie 的访问者区分开来。

[`noscript`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/noscript?redirectlocale=en-US&redirectslug=HTML%2FElement%2Fnoscript)块在 JavaScript 被禁用时执行，通常用于显示您在 JavaScript 中生成的替代内容，例如

    <script type="javascript">
        ... construction of ajaxy-link,  setting of "js-enabled" cookie flag, etc..
    </script>
    <noscript>
        <a href="next_page.php?nojs=1">Next Page</a>
    </noscript>
    

没有 js 的用户将获得`next_page`链接 - 您可以在此处添加参数，以便在下一页上知道他们是否通过 JS/非 JS 链接访问，或者尝试通过 JS 设置 cookie，如果没有 JS 则意味着 JS被禁用。这两个例子都相当琐碎并且容易被操纵，但你明白了。

如果您想要纯粹统计有多少用户禁用了 javascript，您可以执行以下操作：

    <noscript>
        <img src="no_js.gif" alt="Javascript not enabled" />
    </noscript>
    

然后检查您的访问日志以查看该图像被点击了多少次。这是一个稍微粗糙的解决方案，但它会给您一个关于用户群百分比的好主意。

上述方法（图像跟踪）对于纯文本浏览器或根本不支持 js 的浏览器不太适用，因此如果您的用户群主要转向该领域，这可能不是最好的方法。

这对我有用：如果禁用 javascript，它会重定向访问者

    <noscript><meta http-equiv="refresh" content="0; url=whatyouwant.html" /></noscript>

我建议您反其道而行之，编写不引人注目的 JavaScript。

让项目的功能适用于禁用 JavaScript 的用户，完成后，实现 JavaScript UI 增强功能。

[https://en.wikipedia.org/wiki/Unobtrusive\_JavaScript](https://en.wikipedia.org/wiki/Unobtrusive_JavaScript)

如何检测 javascript 是否被禁用？

是的，`:not()` 伪类选择器可以接受多个选择器作为它的参数。这表示可以指定多个条件来排除一组元素。在CSS选择器等级4的规范中，`:not()` 已经得到了扩展，允许它接受逗号分隔的选择器列表作为它的参数，这意味着它可以同时排除多种选择器匹配的元素。

例如，如果你想选择那些既不是类`.class1`也不是类`.class2`的`<p>`元素，你可以这样写：

```css
p:not(.class1, .class2) {
  /* 样式规则 */
}
```

在这个例子中，任何带有`.class1`或`.class2`类的`<p>`元素都不会被选中，而其他所有`<p>`元素都会应用这里定义的样式。

需要注意的是，尽管CSS选择器等级4的规范支持多参数的`:not()`，但并非所有浏览器都实现了这一特性。因此，在使用时应该检查浏览器的兼容性情况，或者使用一些工具，如PostCSS等，来帮助转换这些现代CSS特性，以确保兼容旧版浏览器。在编写代码时，也应该考虑回退方案，以保证功能的正常使用。

为什么：不只使用两个`:not`：

    input:not([type="radio"]):not([type="checkbox"])
    

_是的，这是故意的_

从 CSS 选择器 4 开始，在`:not`选择器中使用多个参数成为可能（[请参见此处](https://www.w3.org/TR/selectors4/#negation)）。

> 在 CSS3 中，:not 选择器只允许 1 个选择器作为参数。在 4 级选择器中，它可以将选择器列表作为参数。

例子：

    /* In this example, all p elements will be red, except for 
       the first child and the ones with the class special. */
    
    p:not(:first-child, .special) {
      color: red;
    }
    

不幸的是，浏览器支持[有点新](https://developer.mozilla.org/en-US/docs/Web/CSS/:not#browser_compatibility)。

如果您在项目中使用 SASS，我构建了这个 mixin 以使其按照我们希望的方式工作：

    @mixin not($ignorList...) {
        //if only a single value given
        @if (length($ignorList) == 1){
            //it is probably a list variable so set ignore list to the variable
            $ignorList: nth($ignorList,1);
        }
        //set up an empty $notOutput variable
        $notOutput: '';
        //for each item in the list
        @each $not in $ignorList {
            //generate a :not([ignored_item]) segment for each item in the ignore list and put them back to back
            $notOutput: $notOutput + ':not(#{$not})';
        }
        //output the full :not() rule including all ignored items
        &#{$notOutput} {
            @content;
        }
    }
    

它可以通过两种方式使用：

**选项 1：内联列出忽略的项目**

    input {
      /*non-ignored styling goes here*/
      @include not('[type="radio"]','[type="checkbox"]'){
        /*ignored styling goes here*/
      }
    }
    

**选项 2：首先列出变量中被忽略的项目**

    $ignoredItems:
      '[type="radio"]',
      '[type="checkbox"]'
    ;
    
    input {
      /*non-ignored styling goes here*/
      @include not($ignoredItems){
        /*ignored styling goes here*/
      }
    }
    

**任一选项的输出 CSS**

    input {
        /*non-ignored styling goes here*/
    }
    
    input:not([type="radio"]):not([type="checkbox"]) {
        /*ignored styling goes here*/
    }

我在这方面遇到了一些麻烦，“X:not():not()”方法对我不起作用。

我最终采用了这个策略：

    INPUT {
        /* styles */
    }
    INPUT[type="radio"], INPUT[type="checkbox"] {
        /* styles that reset previous styles */
    }
    

它并不那么有趣，但当 :not() 好斗时它对我有用。它并不理想，但很坚固。

如果您[安装了“cssnext”Post CSS 插件](https://cssnext.github.io/setup/)，那么您就可以安全地开始使用您现在想要使用的语法。

使用 cssnext 将会变成这样：

    input:not([type="radio"], [type="checkbox"]) {
      /* css here */
    }
    

进入这个：

    input:not([type="radio"]):not([type="checkbox"]) {
      /* css here */
    }
    

[https://cssnext.github.io/features/#not-pseudo-class](https://cssnext.github.io/features/#not-pseudo-class)

`:not()` 伪类选择器可以接受多个选择器作为它的参数。这表示可以指定多个条件来排除一组元素。在CSS选择器等级4的规范中，`:not()` 已经得到了扩展，允许它接受逗号分隔的选择器列表作为它的参数，这意味着它可以同时排除多种选择器匹配的元素。

例如，如果你想选择那些既不是类 `.class1`也不是类 `.class2`的 `<p>`元素，你可以这样写：

```css
p:not(.class1, .class2) {
  /* 样式规则 */
}
```

在这个例子中，任何带有 `.class1`或 `.class2`类的 `<p>`元素都不会被选中，而其他所有 `<p>`元素都会应用这里定义的样式。

需要注意的是，尽管CSS选择器等级4的规范支持多参数的 `:not()`，但并非所有浏览器都实现了这一特性。因此，在使用时应该检查浏览器的兼容性情况，或者使用一些工具，如PostCSS等，来帮助转换这些现代CSS特性，以确保兼容旧版浏览器。在编写代码时，也应该考虑回退方案，以保证功能的正常使用。

所有问题