CSS（Cascading Style Sheets）是一种用于描述文档样式和布局的样式表语言，常用于 Web 开发中。它通过定义样式规则来控制 HTML 元素的外观和布局，使得开发人员可以更加灵活地控制页面的样式和排版。

CSS 的主要特点包括：

分离样式和内容：CSS 可以将样式信息从 HTML 内容中分离出来，使得样式和内容的管理更加清晰和易于维护；
层叠样式：CSS 中的样式规则是可以层叠的，即可以通过多个规则来定义相同的样式，最终的样式由所有规则的组合决定；
继承样式：CSS 中的某些样式可以被子元素继承，使得样式的传递更加自然和方便；
支持多种选择器：CSS 支持多种选择器来选择不同的 HTML 元素，使得样式的应用更加灵活和精确；
支持多种样式属性：CSS 支持多种样式属性，如文本样式、盒模型、背景、边框、定位、动画等，使得开发人员可以控制元素的各个方面。
CSS 在 Web 开发中扮演着非常重要的角色，通过使用 CSS，开发人员可以为网页添加各种样式和布局，使得网页更加美观和易于使用。同时，CSS 也是一门非常灵活和强大的技术，可以用于许多不同的应用场景，如响应式设计、移动应用开发、桌面应用开发等。

`clear:both` 是一个CSS属性，主要用于控制元素周围的浮动布局。在Web开发中，当使用 `float` 属性使得元素浮动时，这些浮动元素会影响到它们周围的非浮动元素，有时会导致布局上的混乱或重叠。`clear:both` 的作用就是阻止元素与前面的任何浮动元素（无论是左浮动还是右浮动）在同一行显示。

举个例子，假设我们有几个通过 `float:left` 或 `float:right` 排列的图像或盒子，并且我们希望紧接着这些浮动元素的下一个内容（比如一个段落 `<p>`）能够出现在一个新的行，而不是紧贴在浮动元素的旁边。这时，我们可以在该段落 `<p>` 上使用 `clear:both`，这样它就会忽略前面的所有浮动元素，从新的一行开始显示。

```html
<div style="float: left;">左侧内容</div>
<div style="float: right;">右侧内容</div>
<p style="clear: both;">这是一个新的段落，将出现在浮动内容下方。</p>
```

在这个例子中，不论左侧或右侧的 `div` 是否浮动，`<p>` 标签都会跳到下一行开始，确保前面的浮动不会影响到它的布局。这个技术在实现多栏布局或处理图文混排的场景中非常有用。

CSS 规则“ clear : both ”的作用是什么？

在Web开发中，有多种方法可以设置偶数和奇数元素的样式，这通常用于列表、表格行或任何重复元素的样式设置。下面是三种常见的方法：

### 1. 使用CSS的`:nth-child`选择器

CSS中的`:nth-child`选择器是一种非常方便的方法来选择偶数或奇数元素。`:nth-child`可以接受公式`(an + b)`作为参数，其中`a`和`b`是常数，这允许我们精确地选择元素序列。

#### 示例代码：

```css
/* 选择偶数元素 */
li:nth-child(even) {
    background-color: #f2f2f2;
}

/* 选择奇数元素 */
li:nth-child(odd) {
    background-color: #ffffff;
}
```

这段代码将会给偶数的`li`元素设置灰色背景，奇数的`li`元素设置白色背景。

### 2. 使用JavaScript或jQuery

当CSS方法不够灵活或需要在运行时根据数据动态设置样式时，JavaScript 或 jQuery 是一个很好的解决方案。

#### 示例代码：

```javascript
// 使用纯JavaScript
const items = document.querySelectorAll('li');
items.forEach((item, index) => {
    if (index % 2 === 0) {
        item.style.backgroundColor = '#f2f2f2'; // 偶数
    } else {
        item.style.backgroundColor = '#ffffff'; // 奇数
    }
});

// 使用jQuery
$('li:even').css('background-color', '#f2f2f2');
$('li:odd').css('background-color', '#ffffff');
```

这些脚本在页面加载时分别为偶数和奇数的列表项设置不同的背景颜色。

### 3. 在服务器端生成CSS类

如果你的网页内容是从服务器动态生成的（例如使用PHP, Python等后端技术），你可以在生成HTML时添加特定的类来区分偶数和奇数项。

#### 示例代码：

```php
<?php
foreach ($items as $index => $item) {
    $class = $index % 2 == 0 ? 'even' : 'odd';
    echo "<li class='$class'>$item</li>";
}
?>
```

然后在CSS中定义这些类：

```css
.even {
    background-color: #f2f2f2;
}

.odd {
    background-color: #ffffff;
}
```

这种方法的好处是它不需要客户端的额外计算，直接从服务器发送已经预处理好的HTML到客户端。

### 总结

根据项目的具体需求和环境，可以选择最合适的方法来实现偶数和奇数元素的样式设置。CSS的`:nth-child`选择器提供了一种纯CSS的解决方案，而JavaScript和服务器端方法提供了更多的灵活性和动态处理的能力。在Web开发中，为偶数和奇数元素设置不同的样式是一个常见的需求，可以通过多种方法实现，主要有以下几种方式：

### 1. CSS选择器

CSS提供了`:nth-child()`伪类选择器，可以用来选择元素的奇数位置或偶数位置的子元素，从而对它们应用不同的样式。例如：

```css
/* 选择偶数位置的li元素 */
li:nth-child(even) {
    background-color: #f2f2f2;
}

/* 选择奇数位置的li元素 */
li:nth-child(odd) {
    background-color: #ffffff;
}
```

这段代码会将位于偶数位置的`<li>`元素的背景设置为灰色，而奇数位置的`<li>`元素背景则为白色。

### 2. JavaScript

如果需要更复杂的逻辑或在CSS不方便处理的情况下，可以使用JavaScript来动态添加样式。例如，使用jQuery可以这样做：

```javascript
$('li:even').css('background-color', '#f2f2f2');
$('li:odd').css('background-color', '#ffffff');
```

这段代码使用jQuery选择所有偶数和奇数位置的`<li>`元素，并分别设置它们的背景颜色。

### 3. 后端渲染

在服务器端渲染页面时，也可以在生成HTML时添加类或样式。例如，在使用PHP渲染列表时：

```php
<?php
for ($i = 1; $i <= 10; $i++) {
    $class = $i % 2 == 0 ? 'even' : 'odd';
    echo "<li class='$class'>Item $i</li>";
}
?>
```

然后在CSS中定义`.even`和`.odd`的样式：

```css
.even {
    background-color: #f2f2f2;
}
.odd {
    background-color: #ffffff;
}
```

这样，每个列表项都会根据它是奇数位置还是偶数位置来应用不同的背景颜色。

### 总结

通过这些方法，我们可以灵活地为偶数和奇数元素设置不同的样式，以达到更好的视觉效果和用户体验。这些技术在网页设计中非常实用，特别是在处理列表、表格或任何需要区分行或项的场景中。

在Web开发中，有多种方法可以设置偶数和奇数元素的样式，这通常用于列表、表格行或任何重复元素的样式设置。下面是三种常见的方法：

### 1. 使用CSS的`:nth-child`选择器

CSS中的`:nth-child`选择器是一种非常方便的方法来选择偶数或奇数元素。`:nth-child`可以接受公式`(an + b)`作为参数，其中`a`和`b`是常数，这允许我们精确地选择元素序列。

#### 示例代码：

```css
/* 选择偶数元素 */
li:nth-child(even) {
    background-color: #f2f2f2;
}

/* 选择奇数元素 */
li:nth-child(odd) {
    background-color: #ffffff;
}
```

这段代码将会给偶数的`li`元素设置灰色背景，奇数的`li`元素设置白色背景。

### 2. 使用JavaScript或jQuery

当CSS方法不够灵活或需要在运行时根据数据动态设置样式时，JavaScript 或 jQuery 是一个很好的解决方案。

#### 示例代码：

```javascript
// 使用纯JavaScript
const items = document.querySelectorAll('li');
items.forEach((item, index) => {
    if (index % 2 === 0) {
        item.style.backgroundColor = '#f2f2f2'; // 偶数
    } else {
        item.style.backgroundColor = '#ffffff'; // 奇数
    }
});

// 使用jQuery
$('li:even').css('background-color', '#f2f2f2');
$('li:odd').css('background-color', '#ffffff');
```

这些脚本在页面加载时分别为偶数和奇数的列表项设置不同的背景颜色。

### 3. 在服务器端生成CSS类

如果你的网页内容是从服务器动态生成的（例如使用PHP, Python等后端技术），你可以在生成HTML时添加特定的类来区分偶数和奇数项。

#### 示例代码：

```php
<?php
foreach ($items as $index => $item) {
    $class = $index % 2 == 0 ? 'even' : 'odd';
    echo "<li class='$class'>$item</li>";
}
?>
```

然后在CSS中定义这些类：

```css
.even {
    background-color: #f2f2f2;
}

.odd {
    background-color: #ffffff;
}
```

这种方法的好处是它不需要客户端的额外计算，直接从服务器发送已经预处理好的HTML到客户端。

### 总结

根据项目的具体需求和环境，可以选择最合适的方法来实现偶数和奇数元素的样式设置。CSS的`:nth-child`选择器提供了一种纯CSS的解决方案，而JavaScript和服务器端方法提供了更多的灵活性和动态处理的能力。

在Web开发中，有多种方法可以设置偶数和奇数元素的样式，这通常用于列表、表格行或任何重复元素的样式设置。下面是三种常见的方法：

### 1. 使用CSS的`:nth-child`选择器

CSS中的`:nth-child`选择器是一种非常方便的方法来选择偶数或奇数元素。`:nth-child`可以接受公式`(an + b)`作为参数，其中`a`和`b`是常数，这允许我们精确地选择元素序列。

#### 示例代码：

```css
/* 选择偶数元素 */
li:nth-child(even) {
    background-color: #f2f2f2;
}

/* 选择奇数元素 */
li:nth-child(odd) {
    background-color: #ffffff;
}
```

这段代码将会给偶数的`li`元素设置灰色背景，奇数的`li`元素设置白色背景。

### 2. 使用JavaScript或jQuery

当CSS方法不够灵活或需要在运行时根据数据动态设置样式时，JavaScript 或 jQuery 是一个很好的解决方案。

#### 示例代码：

```javascript
// 使用纯JavaScript
const items = document.querySelectorAll('li');
items.forEach((item, index) => {
    if (index % 2 === 0) {
        item.style.backgroundColor = '#f2f2f2'; // 偶数
    } else {
        item.style.backgroundColor = '#ffffff'; // 奇数
    }
});

// 使用jQuery
$('li:even').css('background-color', '#f2f2f2');
$('li:odd').css('background-color', '#ffffff');
```

这些脚本在页面加载时分别为偶数和奇数的列表项设置不同的背景颜色。

### 3. 在服务器端生成CSS类

如果你的网页内容是从服务器动态生成的（例如使用PHP, Python等后端技术），你可以在生成HTML时添加特定的类来区分偶数和奇数项。

#### 示例代码：

```php
<?php
foreach ($items as $index => $item) {
    $class = $index % 2 == 0 ? 'even' : 'odd';
    echo "<li class='$class'>$item</li>";
}
?>
```

然后在CSS中定义这些类：

```css
.even {
    background-color: #f2f2f2;
}

.odd {
    background-color: #ffffff;
}
```

这种方法的好处是它不需要客户端的额外计算，直接从服务器发送已经预处理好的HTML到客户端。

### 总结

根据项目的具体需求和环境，可以选择最合适的方法来实现偶数和奇数元素的样式设置。CSS的`:nth-child`选择器提供了一种纯CSS的解决方案，而JavaScript和服务器端方法提供了更多的灵活性和动态处理的能力。
在Web开发中，为偶数和奇数元素设置不同的样式是一个常见的需求，可以通过多种方法实现，主要有以下几种方式：

### 1. CSS选择器

CSS提供了`:nth-child()`伪类选择器，可以用来选择元素的奇数位置或偶数位置的子元素，从而对它们应用不同的样式。例如：

```css
/* 选择偶数位置的li元素 */
li:nth-child(even) {
    background-color: #f2f2f2;
}

/* 选择奇数位置的li元素 */
li:nth-child(odd) {
    background-color: #ffffff;
}
```

这段代码会将位于偶数位置的`<li>`元素的背景设置为灰色，而奇数位置的`<li>`元素背景则为白色。

### 2. JavaScript

如果需要更复杂的逻辑或在CSS不方便处理的情况下，可以使用JavaScript来动态添加样式。例如，使用jQuery可以这样做：

```javascript
$('li:even').css('background-color', '#f2f2f2');
$('li:odd').css('background-color', '#ffffff');
```

这段代码使用jQuery选择所有偶数和奇数位置的`<li>`元素，并分别设置它们的背景颜色。

### 3. 后端渲染

在服务器端渲染页面时，也可以在生成HTML时添加类或样式。例如，在使用PHP渲染列表时：

```php
<?php
for ($i = 1; $i <= 10; $i++) {
    $class = $i % 2 == 0 ? 'even' : 'odd';
    echo "<li class='$class'>Item $i</li>";
}
?>
```

然后在CSS中定义`.even`和`.odd`的样式：

```css
.even {
    background-color: #f2f2f2;
}
.odd {
    background-color: #ffffff;
}
```

这样，每个列表项都会根据它是奇数位置还是偶数位置来应用不同的背景颜色。

### 总结

通过这些方法，我们可以灵活地为偶数和奇数元素设置不同的样式，以达到更好的视觉效果和用户体验。这些技术在网页设计中非常实用，特别是在处理列表、表格或任何需要区分行或项的场景中。

如何设置偶数和奇数元素的样式？

在CSS中，可以使用伪元素`::first-letter`来选中并样式化一个块级元素中的第一个字符。通过设置`::first-letter`的`text-transform`属性为`capitalize`，可以实现将第一个字母大写的效果。

下面是一个具体的例子：

```css
p::first-letter {
    text-transform: capitalize;
    font-size: 24px;
    font-weight: bold;
}
```

在这个例子中，我们选择了一个段落（`<p>`元素）中的第一个字母，并使其字母大写。同时，我们还增加了字体大小和字重，以使第一个字母更加突出。

HTML代码如下：

```html
<p>这是一个段落，第一个字符将被大写并加粗显示。</p>
```

浏览器渲染后，段落中的第一个汉字“这”会被转换为大写（如果它是英文字母的话），并且字体会更大、更粗。

需要注意的是，`text-transform: capitalize;` 并不会改变汉字的形式，因为汉字没有大小写之分，但它对英文字符有效。如果想要突出汉字，可能需要使用其他CSS属性，比如修改字体大小或颜色。

在 CSS 中怎么使第一个字符大写？

在 CSS 中，伪元素 `::before` 和 `::after` 通常用于在元素的内容前后添加装饰性内容。如果想要移除这些伪元素，可以通过设置伪元素的 `content` 属性为 `none` 来实现。下面是具体的方法和例子：

### CSS 代码示例

假设你有一个使用 `::before` 或 `::after` 伪元素的 HTML 元素，例如一个类名为 `.decorated` 的段落：

```html
<p class="decorated">这是一个带有装饰的段落。</p>
```

该段落通过 CSS 添加了一些装饰：

```css
.decorated::before {
    content: "★ ";
    color: red;
}

.decorated::after {
    content: " ★";
    color: red;
}
```

如果你想移除这些装饰，可以通过设置伪元素的 `content` 属性为 `none`：

```css
.decorated::before,
.decorated::after {
    content: none;
}
```

### 实际应用场景

这种方法在响应式设计中特别有用，可能在移动视图中你不想显示某些装饰性内容。例如，当屏幕尺寸小于某个特定宽度时，你可以使用媒体查询来移除这些伪元素：

```css
@media (max-width: 600px) {
    .decorated::before,
    .decorated::after {
        content: none;
    }
}
```

这样，在宽度小于 600px 的设备上，`.decorated` 元素就不会显示 `::before` 和 `::after` 添加的装饰内容。

总之，通过将 `content` 属性设置为 `none`，可以有效地移除 `::before` 和 `::after` 伪元素，从而对不同的设备和视图提供更精细的控制。

CSS 怎么移除伪元素 after before？

当然可以，CSS 提供了多种方式来选择没有特定类或属性的元素。

### 1. 使用 `:not()` 伪类选择器
`:not()` 是一个功能强大的伪类选择器，可以用来选择不匹配给定选择器的所有元素。例如，如果你想选择所有不含有特定类 `.class-name` 的元素，你可以这样写：

```css
:not(.class-name) {
    /* 样式规则 */
}
```

这条规则会应用到所有没有 `.class-name` 类的元素上。

### 2. 结合属性选择器
如果你想选择没有某个特定属性或属性值的元素，你也可以使用 `:not()` 与属性选择器结合使用。比如，选择所有不含有 `data-type` 属性的元素：

```css
:not([data-type]) {
    /* 样式规则 */
}
```

或者选择属性 `data-type` 不等于 "example" 的所有元素：

```css
:not([data-type="example"]) {
    /* 样式规则 */
}
```

### 示例应用场景
假设你正在开发一个网站，需要为除了标题外的所有文本添加特定样式。你可以使用 `:not()` 选择器来排除标题元素（假设所有标题都有一个 `.title` 类）：

```css
:not(.title) {
    font-size: 16px;
    color: #666;
}
```

这会将样式应用于所有没有 `.title` 类的元素，从而让你可以更精确地控制页面上的样式应用。

### 结论
使用 CSS 的 `:not()` 选择器，你可以非常灵活地选择没有特定类或属性的元素，进而为它们定义样式。这种方式使得 CSS 样式更加模块化和易于管理。

我可以写一个CSS选择器来选择没有特定类或属性的元素吗？

在CSS中，如果你想要在文本中实现换行，但又不想使用 `<br/>` 标签，有几种方法可以实现这一点：

### 1. 使用 `white-space` 和 `content` 属性
如果要在特定的元素中添加换行，可以使用 `::after` 伪元素来在内容的后面添加一个换行。示例如下：

```html
<div class="wrap-text">
  这是一段很长的文本这是一段很长的文本这是一段很长的文本
</div>
```

```css
.wrap-text::after {
  content: '\A'; /* Unicode换行符 */
  white-space: pre; /* 保持空白符的处理，允许使用 \A 生成的换行生效 */
}
```

这段代码会在 `.wrap-text` 的内容后面添加一个换行。

### 2. 控制容器的宽度
另一个方法是通过限制容器的宽度来迫使文本换行。这不需要任何特殊的CSS属性，只需设置容器的 `width` 或 `max-width` 属性，让内部的文本因为没有足够的空间而换行。示例如下：

```html
<div class="limited-width">
  这是一段很长的文本这是一段很长的文本这是一段很长的文本
</div>
```

```css
.limited-width {
  max-width: 200px; /* 限制最大宽度 */
}
```

这种方法通过CSS控制容器的宽度，使得文本在达到最大宽度时自动换行。

### 3. 使用 `word-break` 或 `overflow-wrap`
如果文本包含长单词或URL链接，可以使用 `word-break` 或 `overflow-wrap` 属性来确保文本在达到边界时正确换行。示例如下：

```html
<div class="break-word">
  这是一段包含超长单词的文本superlongwordthatneedstobreakproperly
</div>
```

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

这里的 `word-break: break-all;` 确保单词在任何字符间都可以断开换行。

这些方法提供了在不使用 `<br/>` 的情况下控制CSS文本换行的灵活性，可以根据具体的需求选择合适的方式。


CSS 中如何在不使用< br />的情况下换行？

在JavaScript中创建`<style>`标签，然后将其插入到HTML文档的`<head>`部分是一种添加或修改页面样式的常见方法。以下是一个具体的步骤示例，描述了如何使用JavaScript实现这一过程：

1. **创建`<style>`元素**：首先，需要使用`document.createElement`方法创建一个新的`<style>`元素。

2. **设置样式内容**：然后，可以使用`textContent`属性或`appendChild`方法与`createTextNode`来设置CSS样式规则。

3. **将`<style>`元素插入文档头部**：最后，使用`document.head.appendChild`方法将新创建的`<style>`标签添加到文档的`<head>`部分。

下面是一个具体的实现代码：

```javascript
// 创建一个新的style元素
var style = document.createElement('style');

// 设置CSS规则
// 例子：为body设置背景颜色和字体颜色
style.textContent = `
  body {
    background-color: #f3f3f3;
    color: #333;
  }
`;

// 将style元素插入到head中
document.head.appendChild(style);
```

在上面的例子中，我设置了页面的背景颜色和字体颜色。当然，可以根据需要添加任何CSS规则。这种方法可以动态地控制页面的样式，并且可以用于根据用户交互或其他事件来调整样式。

如何使用Javascript创建＜style＞标签？

在CSS中设置边框的不透明度可以通过几种方法来实现，最常用的方法之一是使用 `rgba()` 函数来设置边框的颜色和透明度。

### 方法1: 使用 `rgba()`

`rgba()` 函数允许我们指定颜色的红(R)、绿(G)、蓝(B) 三原色的值及其透明度(A)。这里的A代表Alpha通道，它的取值范围是0（完全透明）到1（完全不透明）。例如，如果你想为一个元素设置一个半透明的红色边框，可以这样写：

```css
.element {
    border: 3px solid rgba(255, 0, 0, 0.5); /* 0.5 表示50%的透明度 */
}
```

### 例子
假设我们有一个 `<div>` 元素，我们想给它加一个半透明的蓝色边框：

HTML结构：
```html
<div class="transparent-border">这是一段文本。</div>
```

CSS样式：
```css
.transparent-border {
    border: 4px solid rgba(0, 0, 255, 0.3); /* 蓝色边框，30%透明度 */
    padding: 10px;
    text-align: center;
}
```

这段代码会显示一个带有半透明蓝色边框的 `<div>`。边框的透明度可以通过调整 `rgba()` 函数中的最后一个参数来控制。

### 方法2: 使用 `hsla()`

另一个选择是使用 `hsla()` 函数，它类似于 `rgba()`，但是使用色调(Hue)、饱和度(Saturation)、亮度(Lightness)和透明度(Alpha)来定义颜色。

```css
.element {
    border: 3px solid hsla(120, 100%, 50%, 0.5); /* 绿色，50%透明度 */
}
```

在工作中，根据具体的设计需求选择合适的颜色和透明度模型（RGB或HSL），并合理应用它们来增强网页的视觉效果是很重要的。这样能够保持设计的一致性，同时也让用户界面看起来更加美观和专业。

如何在 CSS 中设置边框不透明度？

当您想要在网页上将文本和SVG元素对齐时，有几种CSS技术可以帮助您实现这一点。以下是几种不同的方法：

### 使用Flexbox

Flexbox是一种非常流行且强大的布局模型，可以轻松地对齐文本和SVG。要使用Flexbox，您需要将文本和SVG元素放入同一个容器中，并为该容器设置`display: flex;`样式。然后，您可以使用`align-items`和`justify-content`属性来控制交叉轴和主轴上的对齐。

```css
.container {
  display: flex;
  align-items: center; /* 垂直居中 */
  justify-content: center; /* 水平居中 */
}
```

```html
<div class="container">
  <svg width="100" height="100">...</svg>
  <span>文本内容</span>
</div>
```

### 使用Grid

CSS Grid同样是一个强大的布局系统，可以轻松地对齐项目。您可以在容器上设置`display: grid;`，然后使用`align-items`和`justify-items`来控制对齐。

```css
.container {
  display: grid;
  align-items: center;
  justify-items: center;
}
```

```html
<div class="container">
  <svg width="100" height="100">...</svg>
  <span>文本内容</span>
</div>
```

### 使用Vertical-align

对于行内元素和行内块元素，`vertical-align`属性可以用来调整元素的垂直对齐。如果您的SVG和文本是行内或行内块级别的，可以使用`vertical-align`。

```css
.svg-inline {
  vertical-align: middle;
}
.text-inline {
  vertical-align: middle;
}
```

```html
<svg class="svg-inline" width="100" height="100">...</svg>
<span class="text-inline">文本内容</span>
```

### 使用Position

您还可以使用定位属性手动对齐文本和SVG。这通常涉及设置SVG或文本的`position`为`absolute`，然后使用`top`、`right`、`bottom`和`left`属性来精确定位。

```css
.container {
  position: relative;
}
.svg-absolute {
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
}
```

```html
<div class="container">
  <svg class="svg-absolute" width="100" height="100">...</svg>
  <span>文本内容</span>
</div>
```

每种方法都有其适应的场景和优势。选择哪一种取决于您具体的布局需求和对浏览器兼容性的考虑。在实际的项目中，可能需要根据具体情况调整样式以达到最佳效果。

CSS 如何将文本与 SVG 元素对齐？

`z-index`属性在CSS中用来控制一个元素在页面上垂直堆叠的顺序。`z-index`只能影响定位元素（即`position`属性值为`relative`, `absolute`, `fixed`, 或者 `sticky`的元素）。

`z-index`的值是整数，可以是正数、负数或者0。 

- **最小值：** `z-index`的最小值是负无限，理论上没有具体的数字限制，但实际上它受到浏览器的限制。在实际应用中，通常会使用负值，比如-1, -10, -100等来将元素放置在堆叠顺序的较低层次。
  
- **最大值：** 同样的，理论上的最大值是正无限，但实际使用时也受到浏览器的限制。在大多数现代浏览器中，最大值通常是2147483647（这个数字是32位整数能表示的最大正数）。

例如，如果你有一个模态对话框，你可能会给它一个非常高的`z-index`值，比如1000，以确保它覆盖在其他页面内容之上。反之，如果你想让某个元素显示在大多数其他元素之下，你可能会给它指定一个负的`z-index`值。

需要注意的是，`z-index`的作用是相对的，它只和同一堆叠上下文中的其他元素进行比较。创建新的堆叠上下文会影响`z-index`的行为，例如设置`opacity`小于1或者应用`transform`等也会创建新的堆叠上下文。

[http://www.w3.org/TR/CSS21/visuren.html#z-index](http://www.w3.org/TR/CSS21/visuren.html#z-index)

> **'z 索引'**
> 
> _值_：自动| <整数> |继承

[http://www.w3.org/TR/CSS21/syndata.html#numbers](http://www.w3.org/TR/CSS21/syndata.html#numbers)

> 某些值类型可能具有整数值（由 <integer> 表示）或实数值（由 <number> 表示）。实数和整数仅以十进制表示法指定。 <integer> 由一个或多个数字“0”到“9”组成。 <number> 可以是 <integer>，也可以是零个或多个数字，后跟一个点 (.)，后跟一个或多个数字。整数和实数前面都可以带有“-”或“+”来指示符号。 -0 相当于 0 并且不是负数。
> 
> 请注意，许多允许整数或实数作为值的属性实际上将值限制在某个范围内，通常是非负值。

所以基本上 CSS 标准中的 z-index 值没有限制，但我猜大多数浏览器在实践中将其限制为带符号的 32 位值（−2147483648 到 +2147483647）（64 有点偏离顶部，而且它如今使用小于 32 位的任何东西都没有意义）

我的测试显示这`z-index: 2147483647`是最大值，在 OS X 的 FF 3.0.1 上测试。我发现了一个整数溢出错误：如果您输入`z-index: 2147483648`（即 2147483647 + 1），该元素就会排在所有其他元素后面。至少浏览器不会崩溃。

我们要吸取的教训是，您应该小心不要为属性输入太大的值，`z-index`因为它们会环绕。

根据经验，我认为正确的最大值`z-index`是 2147483647。

它是 32 位整数的最大值：2147483647

另请参阅文档：[https://www.w3.org/TR/CSS22/visuren.html#z-index](https://www.w3.org/TR/CSS22/visuren.html#z-index) （允许负数）

结论 z 索引最大值为 2,147,483,647，超过此值将转换为 2,147,483,647

‌浏览器

最大限度

超过最大值

铬> = 29

2,147,483,647

2,147,483,647

歌剧 >= 9

2,147,483,647

2,147,483,647

IE >= 6

2,147,483,647

2,147,483,647

Safari >= 4

2,147,483,647

2,147,483,647

狩猎 = 3

16,777,271

16,777,271

火狐 >= 4

2,147,483,647

2,147,483,647

火狐 = 3

2,147,483,647

0

火狐 = 2

2,147,483,647

Bug：标签隐藏

所有值均在 BrowserStack 中测试。

CSS 中 z-index 的最小值和最大值是多少？

CSS 中的媒体查询（Media Queries）是一种非常有用的工具，它可以根据不同的设备特性来应用不同的样式规则。针对 iOS 设备的样式，可以通过特定的媒体查询来针对性地应用。

例如，可以使用 `-webkit-min-device-pixel-ratio` 特性或者 `orientation` 特性来针对 iOS 设备。以下是针对所有具有 Retina 屏幕的 iOS 设备（iPhone、iPad、iPod Touch 等）的媒体查询：

```css
@media only screen and (-webkit-min-device-pixel-ratio: 2), only screen and (min-device-pixel-ratio: 2) {
    /* 在这里编写针对 iOS Retina 设备的 CSS */
}
```

如果要更细致地区分，还可以根据设备的宽度或者高度来写媒体查询，因为不同的 iOS 设备（尤其是横竖屏切换时）的宽度和高度是不同的。比如，针对所有的 iPhone 设备（这里不区分是否为 Retina 屏幕），可以这样写：

```css
@media only screen and (max-device-width: 480px) {
    /* 在这里编写专门针对 iPhone 的 CSS */
}
```

对于 iPad，可以这样区分横竖屏：

```css
/* Portrait */
@media only screen 
  and (min-device-width: 768px) 
  and (max-device-width: 1024px) 
  and (orientation: portrait) {
  /* Styles */
}

/* Landscape */
@media only screen 
  and (min-device-width: 768px) 
  and (max-device-width: 1024px) 
  and (orientation: landscape) {
  /* Styles */
}
```

值得注意的是，目前市面上的设备种类繁多，iOS 设备也在不断更新，所以需要定期更新你的媒体查询以适应新的设备。此外，使用这些媒体查询时，还应该注意浏览器兼容性和隐私设置，因为某些浏览器可能不支持特定的查询，或者用户的隐私设置可能会限制某些CSS的应用。在CSS中，我们可以使用媒体查询(media queries)来为不同的设备和视口尺寸应用不同的样式。如果想要只针对iOS设备的话，可以使用针对特定设备特性的媒体查询。但是，需要注意的是，由于iOS设备的多样性和Web标准的推进，通常不建议只针对iOS设备编写CSS，而应该更注重响应式设计，以适应不同的屏幕尺寸和分辨率。

不过，如果确实有特殊需求只想针对iOS设备，可以使用以下的媒体查询示例：

```css
@media screen and (min-device-width : 375px) 
               and (max-device-width : 812px) 
               and (-webkit-device-pixel-ratio : 3) 
               and (orientation : portrait) {
  /* 在 iPhone X 上应用的样式 */
}
```

这个例子使用了`min-device-width`和`max-device-width`来指定设备的屏幕宽度范围，`-webkit-device-pixel-ratio`用来指定设备的像素比，`orientation`用来指定设备的方向。这些参数的组合可以较为准确地针对特定的iOS设备。

然而，这种方法有一些限制：

1. **设备更新**：随着新设备的发布，可能需要更新媒体查询以包括新的尺寸和像素密度。
2. **兼容性和维护**：仅针对iOS设备的样式可能导致不必要的复杂性和后期维护问题。
3. **Web标准**：建议根据Web标准进行设计，使用响应式布局来适配不同的设备和屏幕尺寸，而不是专注于特定品牌或平台。

因此，尽管可以使用媒体查询针对iOS设备，但是最好的做法是编写灵活的响应式CSS，以确保在各种设备上都能提供良好的用户体验。

如上所述，简短的答案是否定的。但我现在正在开发的应用程序中需要类似的东西，但 CSS 需要不同的区域仅限于页面的非常特定的区域。

如果您像我一样并且不需要提供完全不同的样式表，另一种选择是按照此问题所选答案中描述的方式检测运行 iOS 的设备：[检测设备是否为 iOS](https://stackoverflow.com/questions/9038625/detect-if-device-is-ios)

一旦您检测到 iOS 设备，您就可以使用 Javascript（例如，`document.getElementsByTagName("yourElementHere")[0].setAttribute("class", "iOS-device");`jQuery、PHP 等）向您的目标区域添加一个类，并使用预先存在的样式表相应地设置该类的样式。

    .iOS-device {
          style-you-want-to-set: yada;
    }

当您想要使用 CSS 媒体查询专门为 iOS 设备编写样式时，可以通过针对特定的设备特性（如屏幕尺寸、分辨率和操作系统特有的视口属性）来编写媒体查询。尽管我们不能直接查询设备是否为iOS设备，但我们可以使用一些常见的iOS设备的屏幕尺寸和分辨率作为参考来编写媒体查询。以下是一个简单的例子：

```css
@media only screen 
  and (min-device-width : 375px) 
  and (max-device-width : 812px) 
  and (-webkit-device-pixel-ratio : 3) 
  and (orientation : portrait) {
  /* 在这里编写针对特定iOS设备的样式，例如 iPhone X */
  body {
    background-color: lightblue;
  }
}
```

在这个媒体查询中，我们设置了几个条件：

- `min-device-width` 和 `max-device-width` 处于特定范围内，这个范围匹配了特定的 iPhone 设备。
- `-webkit-device-pixel-ratio` 是设备像素比，`3` 是 iPhone X 的设备像素比。
- `orientation` 是设备的方向，这里设置为 `portrait`（竖屏）。

需要注意的是，随着设备的更新和新增，可能需要更新媒体查询条件以适应新的设备。此外，一些媒体查询参数也可能在未来的iOS版本中发生变化，因此需要定期检查您的媒体查询代码，确保其仍然适用于最新的设备和操作系统。

要使用 CSS 媒体查询针对 iOS 设备应用样式，我们可以依赖于特定的设备和浏览器特性，如 `Webkit` 特有的前缀和设备分辨率。下面是一个使用媒体查询只针对 iOS 设备的示例：

```css
@media only screen 
  and (min-device-width : 320px) 
  and (max-device-width : 812px) 
  and (-webkit-min-device-pixel-ratio : 2) 
  and (orientation : portrait) {
    /* 在此处编写你的 CSS 规则 */
    body {
        background-color: #f0f0f0;
    }
}
```

这段样式声明是为了匹配一定分辨率范围内的 iOS 设备（如 iPhone 5/SE, 6/7/8, 6/7/8 Plus, X, XS, 11 Pro 等），并且具有 `2` 倍的像素比（`-webkit-min-device-pixel-ratio : 2`），且设备处于竖屏模式。`-webkit-` 前缀用于针对基于 Webkit 的浏览器，而 iOS 设备的 Safari 浏览器正是建立在这个引擎之上。

请注意，上述媒体查询可能并不完美地涵盖所有 iOS 设备，因为设备的尺寸和分辨率多种多样，而且新设备的发布也可能改变情况。因此，适配 iOS 设备的策略可能需要根据具体情况定期更新。

如果你想针对所有 iOS 设备，而不仅仅是 iPhone，那么你可以省略尺寸的限制，只使用 `-webkit-min-device-pixel-ratio` 这个特性。但这种方法也可能会影响到其他使用 Webkit 浏览器引擎的设备。因此，确保测试你的媒体查询以验证它们是否满足你的需求是非常重要的。

在CSS中，我们可以使用媒体查询(media queries)来为不同的设备和视口尺寸应用不同的样式。如果想要只针对iOS设备的话，可以使用针对特定设备特性的媒体查询。但是，需要注意的是，由于iOS设备的多样性和Web标准的推进，通常不建议只针对iOS设备编写CSS，而应该更注重响应式设计，以适应不同的屏幕尺寸和分辨率。

不过，如果确实有特殊需求只想针对iOS设备，可以使用以下的媒体查询示例：

```css
@media screen and (min-device-width : 375px) 
               and (max-device-width : 812px) 
               and (-webkit-device-pixel-ratio : 3) 
               and (orientation : portrait) {
  /* 在 iPhone X 上应用的样式 */
}
```

这个例子使用了`min-device-width`和`max-device-width`来指定设备的屏幕宽度范围，`-webkit-device-pixel-ratio`用来指定设备的像素比，`orientation`用来指定设备的方向。这些参数的组合可以较为准确地针对特定的iOS设备。

然而，这种方法有一些限制：

1. **设备更新**：随着新设备的发布，可能需要更新媒体查询以包括新的尺寸和像素密度。
2. **兼容性和维护**：仅针对iOS设备的样式可能导致不必要的复杂性和后期维护问题。
3. **Web标准**：建议根据Web标准进行设计，使用响应式布局来适配不同的设备和屏幕尺寸，而不是专注于特定品牌或平台。

因此，尽管可以使用媒体查询针对iOS设备，但是最好的做法是编写灵活的响应式CSS，以确保在各种设备上都能提供良好的用户体验。

要使用 CSS 媒体查询针对 iOS 设备应用样式，我们可以依赖于特定的设备和浏览器特性，如 `Webkit` 特有的前缀和设备分辨率。下面是一个使用媒体查询只针对 iOS 设备的示例：

```css
@media only screen 
  and (min-device-width : 320px) 
  and (max-device-width : 812px) 
  and (-webkit-min-device-pixel-ratio : 2) 
  and (orientation : portrait) {
    /* 在此处编写你的 CSS 规则 */
    body {
        background-color: #f0f0f0;
    }
}
```

这段样式声明是为了匹配一定分辨率范围内的 iOS 设备（如 iPhone 5/SE, 6/7/8, 6/7/8 Plus, X, XS, 11 Pro 等），并且具有 `2` 倍的像素比（`-webkit-min-device-pixel-ratio : 2`），且设备处于竖屏模式。`-webkit-` 前缀用于针对基于 Webkit 的浏览器，而 iOS 设备的 Safari 浏览器正是建立在这个引擎之上。

请注意，上述媒体查询可能并不完美地涵盖所有 iOS 设备，因为设备的尺寸和分辨率多种多样，而且新设备的发布也可能改变情况。因此，适配 iOS 设备的策略可能需要根据具体情况定期更新。

如果你想针对所有 iOS 设备，而不仅仅是 iPhone，那么你可以省略尺寸的限制，只使用 `-webkit-min-device-pixel-ratio` 这个特性。但这种方法也可能会影响到其他使用 Webkit 浏览器引擎的设备。因此，确保测试你的媒体查询以验证它们是否满足你的需求是非常重要的。CSS 中使用媒体查询（Media Queries）可以根据不同的设备特性来应用不同的样式规则。如果想特别针对 iOS 设备，我们需要定义一种特定的媒体查询，它能够识别出 iOS 设备的特征。然而，CSS 并没有直接针对 iOS 的媒体查询，因为媒体查询基于设备的能力而不是平台或操作系统。

不过，我们可以使用一些常见的iOS设备分辨率和特性（如设备的宽度、高度和像素比）来间接地定位大部分iOS设备。例如，iPhone、iPad和iPod通常都有特定的屏幕尺寸和分辨率。以下是一个CSS媒体查询的例子，它可能会捕捉到一些iOS设备，但不保证完全精确：

```css
/* iPhone 的横向和纵向 */
@media only screen 
  and (min-device-width : 375px) 
  and (max-device-width : 812px) 
  and (-webkit-min-device-pixel-ratio : 3) {
    /* 在这里编写针对特定设备的CSS代码 */
}

/* 特定于iPad的媒体查询 */
@media only screen 
  and (min-device-width : 768px) 
  and (max-device-width : 1024px) 
  and (-webkit-min-device-pixel-ratio : 2) {
    /* 在这里编写针对特定设备的CSS代码 */
}

/* 可能适用于大多数iOS设备的高像素比 */
@media only screen 
  and (-webkit-min-device-pixel-ratio : 2), 
  only screen 
  and (min--moz-device-pixel-ratio : 2),
  only screen 
  and (-o-min-device-pixel-ratio : 2/1),
  only screen 
  and (min-device-pixel-ratio : 2),
  only screen 
  and (min-resolution : 2dppx) {
    /* 在这里编写针对高像素比设备的CSS代码 */
}
```

但是，要注意，这样的媒体查询并不能保证只会被iOS设备使用，因为其他具有类似特征的非iOS设备（比如其他制造商的高分辨率手机或平板电脑）也可能匹配这些规则。

另一个可能的方法是用JavaScript来检测用户代理（User Agent）字符串中是否含有iOS特有的标识符，然后动态添加一个对应的类名到`<body>`标签或在页面上动态写入特定的CSS。但是这种方法同样不是完全可靠的，因为用户代理字符串可能被伪造或因浏览器更新而改变。

```javascript
if (/iPad|iPhone|iPod/.test(navigator.userAgent)) {
    document.documentElement.className += " ios-device";
}
```

然后，在CSS中，您可以这样做：

```css
.ios-device .some-class {
    /* 特定于 iOS 设备的样式 */
}
```

所以，在实际操作中，我们通常会根据设备的屏幕大小和分辨率来编写媒体查询，而不是试图创建一个完全针对iOS设备的查询。这种做法更加通用，并且更能适应各种设备的屏幕。

CSS 如何利用媒体查询只针对 ios 设备？

要在页面加载过程中使用 CSS3 过渡动画，你可以通过以下步骤实现：

1. **定义 CSS 过渡样式规则**：在CSS中为目标元素创建初始状态和过渡效果。例如，你可能想让一个元素从透明度为0变化到透明度为1，以实现淡入效果。

2. **设置初始状态**：通过在页面的`<style>`标签或外部 CSS 文件中设置目标元素的样式，为其赋予初始状态（比如 `opacity: 0;`）。

3. **设置过渡效果**：使用 `transition` 属性来定义过渡效果的持续时间和效果曲线。

4. **触发过渡**：页面加载时，通过 JavaScript 或者在DOM中添加一个类（class）来改变目标元素的状态，触发CSS过渡效果。

下面是一个简单的示例：

```html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Page Load Transition Example</title>
<style>
/* 初始状态，元素不可见 */
.element {
  opacity: 0;
  transition: opacity 2s ease-in-out;
}

/* 页面加载后的状态，元素逐渐变得可见 */
.element.loaded {
  opacity: 1;
}
</style>
</head>
<body>
<div class="element">Hello, World!</div>

<script>
window.addEventListener('DOMContentLoaded', (event) => {
  // 一旦DOM加载完成，给元素添加 'loaded' 类来触发过渡
  document.querySelector('.element').classList.add('loaded');
});
</script>
</body>
</html>
```

在这个示例中，`.element` 初始状态是不可见的 (`opacity: 0;`)。当文档的 DOMContentLoaded 事件被触发时（即页面的HTML被完全加载和解析时，但不一定要等待样式表、图像和子框架完成加载），JavaScript 将添加 `loaded` 类到 `.element`，从而触发一个 2 秒的淡入效果，使元素从完全透明渐变到完全不透明 (`opacity: 1;`)。

请注意，实际开发中常常还需要考虑浏览器的兼容性以及对无法执行JavaScript的情况的处理。此外，过渡效果对性能有一定影响，尤其是当涉及到大量元素或复杂的动画时。

可以在页面加载时运行**CSS**动画，而无需使用任何 JavaScript；你只需要使用**CSS3关键帧**。

## 例子 

**以下是仅使用CSS3**滑动到位的导航菜单的演示：

```
@keyframes slideInFromLeft {
  0% {
    transform: translateX(-100%);
  }
  100% {
    transform: translateX(0);
  }
}

header {  
  /* This section calls the slideInFromLeft animation we defined above */
  animation: 1s ease-out 0s 1 slideInFromLeft;
  
  background: #333;
  padding: 30px;
}

/* Added for aesthetics */ body {margin: 0;font-family: "Segoe UI", Arial, Helvetica, Sans Serif;} a {text-decoration: none; display: inline-block; margin-right: 10px; color:#fff;}

<header>
  <a href="#">Home</a>
  <a href="#">About</a>
  <a href="#">Products</a>
  <a href="#">Contact</a>
</header>
```


## 解析

这里重要的部分是关键帧动画，我们称之为 `slideInFromLeft`

```
@keyframes slideInFromLeft {
    0% {
        transform: translateX(-100%);
    }
    100% {
        transform: translateX(0);
    }
}
```

这基本上是说“在开始时，标题将以其整个宽度离开屏幕的左边缘，并在最后将就位”。

第二部分调用该 `slideInFromLeft`动画：

```
animation: 1s ease-out 0s 1 slideInFromLeft;
```

上面是简写版本，但为了清楚起见，这里是详细版本：

```
animation-duration: 1s; /* the duration of the animation */
animation-timing-function: ease-out; /* how the animation will behave */
animation-delay: 0s; /* how long to delay the animation from starting */
animation-iteration-count: 1; /* how many times the animation will play */
animation-name: slideInFromLeft; /* the name of the animation we defined above */
```


[这是 W3C 的说法。](http://www.w3.org/TR/css3-animations/#keyframes)

只需要很少的 JavaScript：

    window.onload = function() {
        document.body.className += " loaded";
    }
    

现在是CSS：

    .fadein {
        opacity: 0;
        -moz-transition: opacity 1.5s;
        -webkit-transition: opacity 1.5s;
        -o-transition: opacity 1.5s;
        transition: opacity 1.5s;
    }
    
    body.loaded .fadein {
        opacity: 1;
    }
    

我知道问题说的是“没有 Javascript”，但我认为值得指出的是，有一个涉及一行 Javascript 的简单解决方案。

它甚至可以是内联 Javascript，类似这样：

    <body onload="document.body.className += ' loaded';" class="fadein">
    

这就是所需的全部 JavaScript。

我想我已经找到了解决OP问题的一种方法 - 而不是从页面的“on.load”开始的过渡 - 我发现使用动画进行不透明度淡入具有相同的效果，（我正在寻找与OP相同）。

所以我想让正文文本在页面加载时从白色（与网站背景相同）淡入黑色文本颜色 - 而且我从周一才开始编码，所以我正在寻找“on.load”样式的代码，但还不知道 JS - 所以这是我的代码，对我来说效果很好。

    #main p {
      animation: fadein 2s;
    }
    @keyframes fadein {
      from { opacity: 0}
      to   { opacity: 1}
    }
    

无论出于何种原因，这`.class`仅适用于`#id`（至少不适用于我的）

希望这会有所帮助 - 据我所知，这个网站对我帮助很大！

**CSS仅延迟3s**

这里需要注意几点：

*   一次调用多个动画
*   我们创建一个**等待**动画，它只是延迟实际的动画（在我们的例子中是第二个动画）。

代码：

    header {
        animation: 3s ease-out 0s 1 wait, 0.21s ease-out 3s 1 slideInFromBottom;
    }
    
    @keyframes wait {
        from { transform: translateY(20px); }
        to { transform: translateY(20px); }
    }
    
    @keyframes slideInFromBottom {
      from { transform: translateY(20px); opacity: 0; }
      to { transform: translateY(0); opacity: 1; }
    }

嗯，这是一个棘手的问题。

答案是“并非如此”。

CSS 不是一个功能层。它不知道发生了什么或何时发生。它仅用于向不同的“标志”（类、id、状态）添加_表示_层。

默认情况下，CSS/DOM 不提供任何类型的“加载”状态供 CSS 使用。如果您想要/能够使用 JavaScript，您可以分配一个类`body`或一些东西来激活某些 CSS。

话虽如此，您可以为此创建一个 hack。我将在这里举一个例子，但它可能适用也可能不适用于您的情况。

我们的操作假设是“接近”就是“足够好”：

    <html>
    <head>
    
    </head>
    <body>
        
        <div class="onLoad">OMG, I've loaded !</div>
    </body>
    </html>
    

以下是 CSS 样式表的摘录：

    .onLoad
    {
        -webkit-animation:bounceIn 2s;
    }
    

我们还假设现代浏览器是渐进渲染的，所以我们的最后一个元素将最后渲染，因此这个 CSS 将最后激活。

Web 页面如何在加载时使用 css3 过渡动画？

在CSS中，将颜色定义为变量可以使用CSS自定义属性，也常被称为CSS变量。这样做可以让你在多处重用同一颜色值，而且如果需要更改颜色，你只需要在一个地方更新定义即可。

下面是如何定义和使用CSS颜色变量的步骤：

1. 首先，在你的CSS文件的`:root`伪类中定义颜色变量。`:root`通常用于全局变量，因为它代表了文档树的根元素，即HTML元素。

```css
:root {
  --primary-color: #3498db;
  --accent-color: #e74c3c;
  --background-color: #ecf0f1;
}
```

2. 一旦定义了变量，你就可以在CSS文件的其他部分使用`var()`函数来引用这些变量。

```css
header {
  background-color: var(--primary-color);
}

button.accent {
  background-color: var(--accent-color);
}

body {
  background-color: var(--background-color);
}
```

在这个例子中，我们定义了三个颜色变量：主色调、强调色和背景色。然后我们在不同的CSS选择器中使用了这些变量，比如`header`、`button`类`.accent`和`body`。

这种方法的好处是，如果未来我们决定更改主题颜色，我们只需要在`:root`中更新变量值，CSS中使用这些变量的地方都会自动使用新的颜色值，使得维护和更新变得非常方便。

[CSS 通过CSS Variables](http://www.w3.org/TR/css-variables/)原生支持这一点。

**CSS 文件示例**

    :root {
        --main-color:#06c;
    }
    
    #foo {
        color: var(--main-color);
    }
    

有关工作示例，请参阅[此 JSFiddle](http://jsfiddle.net/Z4VWc/1/)（该示例显示小提琴中的 CSS 选择器之一将颜色硬编码为蓝色，另一个 CSS 选择器使用 CSS 变量（原始语法和当前语法）将颜色设置为蓝色） 。

**在 JavaScript/客户端操作 CSS 变量**

    document.body.style.setProperty('--main-color',"#6c0")
    

**所有现代浏览器都支持**

[Firefox 31+](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_variables)、[Chrome 49+](https://www.chromestatus.com/features/6401356696911872)、[Safari 9.1+](https://developer.apple.com/library/mac/releasenotes/General/WhatsNewInSafari/Articles/Safari_9_1.html)、[Microsoft Edge 15+](https://wpdev.uservoice.com/forums/257854-microsoft-edge-developer/suggestions/6261292-css-variables)和[Opera 36+](https://dev.opera.com/blog/opera-36/)附带对 CSS 变量的本机支持。

**[人们不断对我的答案进行投票，但与sass](http://sass-lang.com/)或[less](http://lesscss.org/)的乐趣相比，这是一个糟糕的解决方案，特别是考虑[到如今易于使用的 gui 的](https://www.google.co.uk/search?q=sass+or+less+gui)数量。如果您有任何理智，请忽略我下面建议的所有内容。**

您可以在CSS中的每种颜色之前添加注释，以充当一种变量，您可以使用查找/替换来更改它的值，所以...

在css文件的顶部

    /********************* Colour reference chart****************
    *************************** comment ********* colour ******** 
    
    box background colour       bbg              #567890
    box border colour           bb               #abcdef
    box text colour             bt               #123456
    
    */
    

稍后在 CSS 文件中

    .contentBox {background: /*bbg*/#567890; border: 2px solid /*bb*/#abcdef; color:/*bt*/#123456}
    

然后，例如，更改您执行查找/替换的框文本的颜色方案

    /*bt*/#123456

**Yeeeaaahhh ....您现在可以在****CSS**中使用**var(** ) 函数.. ...

好消息是您可以使用**JavaScript**访问来更改它，这也会在全局范围内更改......

但如何声明它们...

这很简单：

例如，你想将 a 分配`#ff0000`给 a `var()`，只需将其分配在 中即可`:root`，还要注意`--`：

    :root {
        --red: #ff0000; 
    }
    
    html, body {
        background-color: var(--red); 
    }
    

好处是浏览器支持还不错，也不需要编译就可以在浏览器中使用，比如`LESS`或`SASS`...

[![浏览器支持](https://i.stack.imgur.com/vl3g6.png)](https://i.stack.imgur.com/vl3g6.png)

另外，这里有一个简单的 JavaScript 脚本，它将红色值更改为蓝色：

    const rootEl = document.querySelector(':root');
    root.style.setProperty('--red', 'blue');

CSS 本身不使用变量。但是，您可以使用另一种语言（例如[SASS）](http://sass-lang.com/)来使用变量定义样式，并自动生成 CSS 文件，然后将其发布到网络上。请注意，每次更改 CSS 时都必须重新运行生成器，但这并不难。

您可以尝试[CSS3 变量](http://www.w3.org/TR/css-variables/)：

    body {
      --fontColor: red;
      color: var(--fontColor);
    }

CSS 如何将颜色定义为变量?

为了隐藏HTML中图像损坏的图标，可以使用CSS的伪元素来覆盖默认的图像损坏图标。以下是一个常用的方法，它利用了`::before`或`::after`伪元素来实现。

```css
img {
  /* 当图像未能加载时，将其内容设置为空 */
  display: block;
  font-family: 'arial';
  color: transparent;
  width: 200px; /* 设置为你希望的宽度 */
  height: 200px; /* 设置为你希望的高度 */
}

img::before {
  /* 在图像位置展示的内容，这里使用空内容来隐藏损坏的图标 */
  content: '';
  display: block;
  width: 100%;
  height: 100%;
  background: #ccc; /* 可以使用其他颜色或背景图案 */
}

img:not([src]), img[src=""] {
  visibility: hidden;
}
```

此代码块做了以下几件事情：

1. **设置图像尺寸**：`width`和`height`属性用于指定图像的占位大小。

2. **隐藏损坏的图标**：使用`img::before`创建一个伪元素，`content`属性设置为空字符串，这将覆盖默认的图像损坏图标。

3. **设置一个备用背景**：可以通过`background`属性设置一个颜色或者图案，作为图像损坏时的背景。这是可选的，如果你不希望有任何东西显示，可以省略这一步。

4. **隐藏没有`src`的图像**：`img:not([src]), img[src=""]`选择器用来选中那些没有`src`属性或者`src`为空字符串的`img`元素，并将其`visibility`属性设置为`hidden`，以确保这些元素不会在页面上显示。

请注意，这种方法的效果可能依赖于不同浏览器的实现以及图像损坏时浏览器的默认行为。此外，如果你希望支持屏幕阅读器用户，隐藏图像的同时请确保使用适当的`alt`文本描述，以便屏幕阅读器仍然可以提供图像的信息。

CSS/HTML 无法知道图像链接是否已损坏，因此无论如何您都必须使用 JavaScript

但这里有一个隐藏图像或用备份替换源的最小方法。

    <img src="Error.src" onerror="this.style.display='none'"/>
    

或者

    <img src="Error.src" onerror="this.src='fallback-img.jpg'"/>
    

更新
--

您可以通过执行以下操作将此逻辑一次应用于多个图像：

    document.addEventListener("DOMContentLoaded", function(event) {
       document.querySelectorAll('img').forEach(function(img){
      	img.onerror = function(){this.style.display='none';};
       })
    });

    <img src="error.src">
    <img src="error.src">
    <img src="error.src">
    <img src="error.src">

运行代码片段Hide results

展开片段

更新2
---

对于**CSS 选项，**请参阅下面[michalzuber 的回答](https://stackoverflow.com/a/37192970/484780)。您无法隐藏整个图像，但可以更改损坏图标的外观。

不管人们在这里怎么说，你根本不需要 JavaScript，甚至不需要 CSS！

实际上，仅使用 HTML 就非常可行且简单。  
**如果图像未加载，您甚至可以显示默认图像**。就是这样...

这也适用于所有浏览器，甚至早到 IE8（在 2015 年 9 月我托管的网站的 250,000 多名访问者中，**零**个人使用了比 IE8 更糟糕的浏览器，这意味着该解决方案几乎适用于**所有浏览器**）。

步骤 1：将图像引用为**对象**而不是**img**。当对象失败时，它们不会显示损坏的图标；他们只是什么都不做。从 IE8 开始，您可以互换使用 object 和 img 标签。您还可以调整大小并使用常规图像做所有您可以做的事情。不要害怕对象标签；它只是一个标签，不会加载任何大而笨重的东西，也不会减慢任何东西。您只需使用另一个名称的 img 标签即可。速度测试表明它们的使用方式相同。

第 2 步：（**可选，但非常棒）**将默认图像粘贴到该对象内。如果您想要的图像实际加载_到对象中_，则默认图像将不会显示。例如，您可以显示用户头像列表，如果某人在服务器上还没有图像，它可以显示占位符图像...根本不需要 JavaScript 或 CSS，但您可以获得以下功能大多数人都需要 JavaScript。

这是代码...

    <object data="avatar.jpg" type="image/jpeg">
        <img src="default.jpg" />
    </object>
    

……是的，就是这么简单。

如果你想用 CSS 实现默认图像，你可以在 HTML 中使其变得更简单，如下所示......

    <object class="avatar" data="user21.jpg" type="image/jpeg"></object>
    

...只需添加此答案中的 CSS -> [https://stackoverflow.com/a/32928240/3196360](https://stackoverflow.com/a/32928240/3196360)

[在https://bitsofco.de/styling-broken-images/](https://bitsofco.de/styling-broken-images/)找到了一个很好的解决方案[](https://bitsofco.de/styling-broken-images/)

    img {  
      position: relative;
    }
    
    /* style this to fit your needs */
    /* and remove [alt] to apply to all images*/
    img[alt]:after {  
      display: block;
      position: absolute;
      top: 0;
      left: 0;
      width: 100%;
      height: 100%;
      background-color: #fff;
      font-family: 'Helvetica';
      font-weight: 300;
      line-height: 2;  
      text-align: center;
      content: attr(alt);
    }

    <img src="error">
    <br>
    <img src="broken" alt="A broken image">
    <br>
    <img src="https://images-na.ssl-images-amazon.com/images/I/218eLEn0fuL.png" alt="A bird" style="width: 120px">

运行代码片段Hide results

展开片段

如果您添加带有文本**alt="abc"**的 alt ，它将显示显示损坏的缩略图，以及 alt 消息 abc

    <img src="pic_trulli.jpg" alt="abc"/>
    

[![第一名](https://i.stack.imgur.com/llfn8.jpg)](https://i.stack.imgur.com/llfn8.jpg)

如果您不添加 alt，它将显示“显示损坏的缩略图”

    <img src="pic_trulli.jpg"/>
    

[![第二名](https://i.stack.imgur.com/iEFO5.jpg)](https://i.stack.imgur.com/iEFO5.jpg)

如果你想隐藏损坏的，只需添加**alt=""**它不会显示损坏的缩略图和任何 alt 消息（不使用 js）

    <img src="pic_trulli.jpg" alt=""/>
    

如果你想隐藏损坏的，只需添加**alt="" & onerror="this.style.display='none'"**它不会显示损坏的缩略图和任何 alt 消息（带有 js）

    <img src="pic_trulli.jpg" alt="abc" onerror="this.style.display='none'"/>
    

第四个有点危险（不完全是），如果你想在onerror事件中添加任何图像，即使图像存在，它也不会显示，因为style.display就像添加一样。因此，当您不需要显示任何替代图像时，请使用它。

    display: 'none'; // in css
    

如果我们在 CSS 中给出它，那么该项目将不会显示（如 image、iframe、div 等）。

如果你想显示图像并且你想在错误时显示完全空白，那么你可以使用，但也要小心这不会占用任何空间。所以，你需要将它保存在 div 中

链接[https://jsfiddle.net/02d9yshw/](https://jsfiddle.net/02d9yshw/)

我认为最简单的方法是通过文本缩进属性隐藏损坏的图像图标。

    img {
        text-indent: -10000px
    }
    

显然，如果你想看到“alt”属性，这是行不通的。

如何只使用 CSS 隐藏 html 的 image 损坏的图标？

在CSS中更改SVG路径的填充颜色通常是通过使用`fill`属性来实现的。首先，你需要确保你的SVG图像是以内联的形式嵌入在HTML中的，因为对于外部引用的SVG文件，CSS可能无法直接影响其样式。

下面是一个简单的例子，演示了如何使用CSS来更改SVG路径的填充颜色：

假设你有以下的SVG代码嵌入在HTML中：

```html
<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">
  <path d="M10 10 h 80 v 80 h -80 Z" />
</svg>
```

在这个SVG中，我们有一个`<path>`元素，它绘制了一个简单的正方形路径。默认情况下，这个路径没有填充颜色。

现在，我们来添加一些CSS来更改这个路径的填充颜色：

```css
svg path {
  fill: #ff0000; /* 设置填充颜色为红色 */
}
```

将这个CSS规则添加到你的样式表中，或者放在`<style>`标签内直接嵌入在HTML中，它会将所有SVG内的`<path>`元素的填充颜色更改为红色。

这个例子展示了一个更改所有SVG路径颜色的通用方法，但你也可以更具体地指定你想要更改颜色的SVG路径，比如使用类名：

HTML:

```html
<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">
  <path class="my-path" d="M10 10 h 80 v 80 h -80 Z" />
</svg>
```

CSS:

```css
svg .my-path {
  fill: #00ff00; /* 设置特定类名的路径填充颜色为绿色 */
}
```

在这个例子中，只有类名为`my-path`的SVG路径的填充颜色会被更改为绿色。这种方法能够让你有选择性地更改特定元素的样式，而不影响其他元素。

是的，您可以将 CSS 应用于 SVG，但您需要匹配元素，就像设置 HTML 样式一样。如果您只想将其应用于所有 SVG 路径，您可以使用，例如：

    ​path {
      fill: blue;
    }​
    

外部 CSS 似乎会覆盖路径的`fill`属性，至少在我测试的基于 WebKit 和 Gecko 的浏览器中是这样。当然，如果你这样写，那么`<path style="fill: green">`它也会覆盖外部 CSS。

如果您想通过将鼠标悬停在元素中来更改颜色，请尝试以下操作：

    path:hover{
      fill:red;
    }

**2021 年 4 月编辑**

如果您进入 SVG 文件的源代码，您可以通过修改填充属性来更改颜色填充。

    <svg fill="#3F6078" height="24" viewBox="0 0 24 24" width="24" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
    </svg> 
    

使用您最喜欢的文本编辑器，打开 SVG 文件并使用它。

我想出了另一种从 SVG 外部更改颜色的方法，那就是导入 SVG 内容并删除声明填充的样式规则。然后从 CSS 样式表中控制填充。

        <svg width="100%" height="100%" viewBox="0 0 167 134" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;"><g id="Pic_icon"><path id="Pic_icon1" serif:id="Pic_icon" d="M166.667,0l-166.667,0l0,133.333l166.667,0l-0,-133.333Zm-158.276,70.89l32.771,-33.148l48.814,49.375l31.519,-19.575l36.781,32.176l-0,-91.3l-149.885,0l-0,62.472Zm84.426,-36.017c11.25,0 20.384,9.164 20.384,20.451c0,11.287 -9.134,20.451 -20.384,20.451c-11.25,0 -20.384,-9.164 -20.384,-20.451c0,-11.287 9.134,-20.451 20.384,-20.451Z" /></g></svg>
    

然后在我的 CSS 文件中我进行以下操作：

        svg{ fill: green; }
    

现在，您正在从 SVG 中删除更高层次结构的填充声明，外部的声明将获得控制。

这对我来说完全没有问题。

**放入所有 svg：**

    fill="var(--svgcolor)"
    

* * *

**在 CSS 中：**

    :root {
      --svgcolor: tomato;
    }
    

**使用伪类：**

    span.github:hover {
      --svgcolor:aquamarine;
    }
    

* * *

**解释**

根= html 页面。  
\--svgcolor = 变量。  
span.github = 选择一个带有 github 类的 span 元素，内部有一个 svg 图标并分配伪类悬停。

你把这个 css 放在 svg 圆圈中。

    svg:hover circle{
        fill: #F6831D;
        stroke-dashoffset: 0;
        stroke-dasharray: 700;
        stroke-width: 2;
    }

CSS 如何更改 svg 路径的填充颜色？

在CSS中，“笑脸”不是一个官方的术语或者特性。不过，可能您提到的“笑脸”是指使用CSS代码来创造的一个笑脸图形。网页设计师和开发者可以通过CSS的各种属性，如`border-radius`、`background`、`box-shadow`等，来设计图形和图案，包括笑脸。

举个例子，要制作一个简单的CSS笑脸，我们可以使用以下的CSS代码：

```css
.smiley-face {
  width: 100px;
  height: 100px;
  background-color: yellow;
  border-radius: 50%;
  position: relative;
}

.smiley-face::before,
.smiley-face::after {
  content: '';
  display: block;
  width: 20px;
  height: 20px;
  background-color: black;
  border-radius: 50%;
  position: absolute;
  top: 30px;
}

.smiley-face::before {
  left: 25px;
}

.smiley-face::after {
  right: 25px;
}

.smiley-face .mouth {
  width: 60px;
  height: 20px;
  background-color: black;
  position: absolute;
  bottom: 20px;
  left: 20px;
  border-radius: 0 0 30px 30px;
}
```

同时，我们需要对应的HTML代码来实现这个笑脸：

```html
<div class="smiley-face">
  <div class="mouth"></div>
</div>
```

上述代码会生成一个简单的笑脸图形，其中`.smiley-face`类创建了一个黄色的圆形，用作脸；`::before`和`::after`伪元素创建了两个黑色的圆形作为眼睛；`.mouth`类创建了一个黑色的半圆形作为嘴巴。通过调整CSS属性，我们可以创作出各种表情和风格的笑脸。

CSS 中的笑脸是什么意思?

在CSS中，`background`和`background-color`是两个有着不同用途的属性。

`background-color`属性用于设置一个元素的背景颜色。它可以接受各种颜色值，比如颜色关键字、十六进制颜色代码、RGB或RGBA值、HSL或HSLA值等。例如：

```css
div {
  background-color: #ff0000; /* 设置背景颜色为红色 */
}
```

另一方面，`background`是一个复合属性，它可以同时设置多个背景相关的属性值，包括`background-color`、`background-image`、`background-repeat`、`background-position`和`background-size`等。使用`background`属性可以让你一次性设置所有这些背景属性。例如：

```css
div {
  background: #ff0000 url('image.jpg') no-repeat center center / cover;
}
```

在上面的例子中，`#ff0000`设置了背景颜色，`url('image.jpg')`设置了背景图片，`no-repeat`指定图片不重复，`center center`指定了图片的位置，而`/ cover`则指定背景图片覆盖整个元素的区域。

使用`background`属性是一种简写方式，它可以减少代码的冗余性并提供更为清晰的代码。不过，有时我们只需要设置背景颜色，这时使用`background-color`更为直接和简单。另外，如果我们想要分别修改背景的某个特定属性，而不影响其他背景属性，使用单独的属性如`background-color`、`background-image`等更合适。

假设这是两个不同的属性，在您的具体示例中，结果没有区别，因为[`background`](https://developer.mozilla.org/en-US/docs/Web/CSS/background)实际上是

>     background-color  
>     background-image  
>     background-position  
>     background-repeat  
>     background-attachment  
>     background-clip  
>     background-origin  
>     background-size
>     

因此，除了 之外[`background-color`](https://developer.mozilla.org/en-US/docs/Web/CSS/background-color)，您还可以使用`background`简写添加一个或多个值，而无需 `background-*`多次重复任何其他属性。

选择哪一个基本上取决于您，但它也可能取决于样式声明的特定条件（例如，如果您需要在从父元素`background-color`继承其他相关`background-*`属性时覆盖，或者如果您需要删除所有值除了`background-color`）。

`background`将取代所有以前的`background-color`、`background-image`等规格。它基本上是一个简写，但也是一个**重置。**

我有时会用它来覆盖`background`模板自定义中的先前规范，我需要以下内容：

`background: white url(images/image1.jpg) top left repeat;`

如下：

`background: black;`

因此，所有参数（`background-image`、`background-position`、`background-repeat`）将重置为其默认值。

关于**CSS 性能**：

**`background`**对比**`background-color`**：

> 比较在页面上以小矩形形式渲染 100 次的 18 个色样，一次使用**背景**，一次使用**背景颜色**。

![背景与背景颜色](https://i.stack.imgur.com/pO46S.png)

> 虽然这些数字来自单个页面重新加载，但随着后续刷新，渲染时间发生了变化，但每次的百分比差异基本相同。
> 
> 在 Safari 7.0.1 中使用背景而不是背景颜色时**，节省了近 42.6 毫秒，几乎是速度的两倍**。 Chrome 33 似乎也差不多。
> 
> 老实说，这让我震惊，因为在很长一段时间里有两个原因：
> 
> *   我通常总是主张 CSS 属性的明确性，尤其是背景，因为它可能会对未来的特异性产生不利影响。
> *   我认为当浏览器看到时`background: #000;`，他们就真的看到了`background: #000 none no-repeat top center;`。我这里没有资源链接，但我记得在某处读过这篇文章。

**参考： https:** [//github.com/mdo/css-perf#background-vs-background-color](https://github.com/mdo/css-perf#background-vs-background-color)

`background`您可以设置所有`background`属性，例如：

*   `background-color`
*   `background-image`  
    
*   `background-repeat`  
    
*   `background-position`  
    **_ETC。_**

* * *

您`background-color`可以只指定背景颜色

    background: url(example.jpg) no-repeat center center #fff;
    

_VS。_

    background-image: url(example.jpg);
    background-position: center center;
    background-repeat: no-repeat;
    background-color: #fff;
    

* * *

[更多信息](http://www.w3schools.com/css/css_background.asp)
-------------------------------------------------------

**_（参见标题：背景 - 速记属性）_**

区别之一：

如果您以这种方式使用图像作为背景：

    background: url('Image Path') no-repeat;
    

那么你不能用“background-color”属性覆盖它。

但如果您使用背景来应用颜色，则它与背景颜色相同并且可以被覆盖。

例如： http: [//jsfiddle.net/Z57Za/11/](http://jsfiddle.net/Z57Za/11/)和[http://jsfiddle.net/Z57Za/12/](http://jsfiddle.net/Z57Za/12/)

CSS 中 background 和 background-color 有什么区别？

`:before` 是一个CSS伪元素，它用于在选择的元素内容的前面插入一些内容。通常，这个伪元素与 `content` 属性一起使用，可以插入文本、图标或其他装饰性内容。

然而，`:before` 伪元素对 `img` 标签不起作用，原因是 `img` 标签是一个替换元素（replacement element）。在HTML中，替换元素通常是指那些不是由CSS渲染的内容，而是由外部资源表示的元素。`img` 元素的内容不是由文档内容直接定义的，而是由它的 `src` 属性指定的外部资源定义的，比如一张图片。

CSS伪元素 `:before` 和 `:after` 是用来为元素的内容添加装饰性内容的，但它们只能应用于那些能够包含子内容的元素，比如 `div`、`span` 或者文本元素等。既然 `img` 元素没有子内容，它是自闭合的标签，并且它的内容是由外部引用定义的，所以是不能使用 `:before` 和 `:after` 伪元素的。

如果你想为图片添加装饰或额外的图形元素，你可以使用一个容器元素（比如 `div`），然后将 `img` 元素放入该容器内。之后，你可以对这个容器使用 `:before` 或 `:after` 伪元素来添加装饰内容。

例如，以下HTML和CSS代码演示了如何给图片添加一个简单的装饰边框：

```html
<div class="image-container">
  <img src="example.jpg" alt="示例图片" />
</div>
```

```css
.image-container {
  position: relative;
  display: inline-block;
}

.image-container:before {
  content: "";
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  border: 2px solid red;
  pointer-events: none; /* 防止伪元素捕获鼠标事件 */
}
```

在这个例子中，`.image-container` 就像是 `img` 的父容器，我们可以在它上面使用 `:before` 伪元素来创建一个边框效果，而这个边框会显示在图片的周围。这种方法允许开发者在图片周围添加虚拟的内容，比如边框、背景或者其他装饰物，而无需修改原始的 `img` 标签。这样的技术可以保持HTML结构的清晰和语义化，同时还能提供灵活的样式设计。

例如，如果你想给图片添加一个悬浮时显示的标题或标签，你可以这样做：

```html
<div class="image-wrapper">
  <img src="example.jpg" alt="示例图片" />
</div>
```

```css
.image-wrapper {
  position: relative;
  display: inline-block;
}

.image-wrapper:before {
  content: "图片标题";
  position: absolute;
  bottom: 0;
  left: 0;
  padding: 5px;
  color: white;
  background-color: rgba(0, 0, 0, 0.7);
  width: 100%;
  opacity: 0;
  transition: opacity 0.3s ease;
  pointer-events: none;
}

.image-wrapper:hover:before {
  opacity: 1;
}
```

在上述代码中，当用户将鼠标悬浮在 `.image-wrapper` 包裹的图片上时，`before` 伪元素中定义的内容（"图片标题"）就会显示出来，作为图片的标题或者说明文字。这种方法同样不会影响到 `img` 元素本身，而是通过包裹元素和CSS伪元素来实现效果。

总的来说，对于不能直接应用 `:before` 和 `:after` 伪元素的替换元素，我们可以通过创造性的方法，例如使用包裹元素或者其他结构性的标签，来模拟出我们想要的效果。这样做的好处是不会对HTML的语义结构造成影响，同时还能保持样式的灵活性和扩展性。

不幸的是，大多数浏览器不支持在 img 标签上使用`:after`或。`:before`

[http://lildude.co.uk/after-css-property-for-img-tag](http://lildude.co.uk/after-css-property-for-img-tag)

然而，您可以使用 JavaScript/jQuery 来完成您所需要的任务。看看这个小提琴：

[http://jsfiddle.net/xixonia/ahnGT/](http://jsfiddle.net/xixonia/ahnGT/)

    $(function() {
    
        $('.target').after('<img src="..." />');
    
    });
    

**_编辑_**：

对于不支持此功能的原因，请查看[coreyward 的回答](https://stackoverflow.com/a/5843164/696056)。

before 和 after 伪选择器不插入 HTML 元素 — 它们在目标元素的现有内容之前或之后插入文本。因为图像元素不包含文本或有后代，所以它们都不`img:before`会对`img:after`您有任何好处。出于同样的原因，类似`<br>`和的元素也是如此。`<hr>`

我找到了一种在纯 css 中实现此功能的方法：

_我只是假内容_\-方法
============

启用 img:after 的纯 CSS 方法。

你可以查看**[CodePen：我只是假内容](http://codepen.io/TimPietrusky/pen/xpesA)**或者查看**来源**。

来源和片段
-----

    img {
        /* hide the default image */
        height:0;
        width:0;
    
        /* hide fake content */
        font-size:0;
        color:transparent;
    
        /* enable absolute position for pseudo elements */
        position:relative;
    
        /* and this is just fake content */
        content:"I'm just fake content";
    }
    
    /* initial absolute position */
    img:before,
    img:after {
        position:absolute;
        top:0;
        left:0;    
    }
    
    /* img:before - chrome & others */
    img:before {
        content:url(http://placekitten.com/g/250/250);
    }
    
    /* img:before - firefox */
    body:not(:-moz-handler-blocked) img:before {
        padding:125px;
        background:url(http://placekitten.com/g/250/250) no-repeat;
    }
    
    /* img:after */
    img:after {
        /* width of img:before */
        left:250px;
    
        content:url(http://lorempixel.com/350/200/city/1);
    }

    <img
        alt="You are watching the ~ I'm just fake content ~ method"  
    />

运行代码片段Hide results

展开片段

### 浏览器支持

✓ Chrome 10+

✓ 火狐 11+

✓ 歌剧 9.8+

✓ 野生动物园

### 没有支持

⊗ Internet Explorer 8 / 9

_请在其他浏览器中测试_

由于[`<img>`](https://www.w3.org/TR/html50/embedded-content-0.html#the-img-element)被[替换元素](https://developer.mozilla.org/en-US/docs/Web/CSS/Replaced_element)的性质，文档样式不会影响它。

无论如何要引用它，[`<picture>`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/picture)提供一个理想的本机包装器，可以附加伪元素，如下所示：

    img::after,
    picture::after{
        content:"\1F63B";
        font-size:larger;
        margin:-1em;
    }

    <img src="//placekitten.com/110/80">
    
    <picture>
        <img src="//placekitten.com/110/80">
    </picture>

运行代码片段Hide results

展开片段

这是另一种解决方案，使用 div 容器作为 img，同时使用`:hover::after`来实现效果。

HTML如下：

    <div id=img_container><img src='' style='height:300px; width:300px;'></img></div>
    

CSS如下：

    #img_container { 
        margin:0; 
        position:relative; 
    } 
    
    #img_container:hover::after { 
        content:''; 
        display:block; 
        position:absolute; 
        width:300px; 
        height:300px; 
        background:url(''); 
        z-index:1; 
        top:0;
    } 
    

要查看它的实际效果，请查看我创建的[小提琴](http://jsfiddle.net/D7C88/)。只是为了让您知道这是跨浏览器友好的，并且无需使用“虚假内容”来欺骗代码。

`:before` 是一个CSS伪元素，它用于在选择的元素内容的前面插入一些内容。通常，这个伪元素与 `content` 属性一起使用，可以插入文本、图标或其他装饰性内容。

然而，`:before` 伪元素对 `img` 标签不起作用，原因是 `img` 标签是一个替换元素（replacement element）。在HTML中，替换元素通常是指那些不是由CSS渲染的内容，而是由外部资源表示的元素。`img` 元素的内容不是由文档内容直接定义的，而是由它的 `src` 属性指定的外部资源定义的，比如一张图片。

CSS伪元素 `:before` 和 `:after` 是用来为元素的内容添加装饰性内容的，但它们只能应用于那些能够包含子内容的元素，比如 `div`、`span` 或者文本元素等。既然 `img` 元素没有子内容，它是自闭合的标签，并且它的内容是由外部引用定义的，所以是不能使用 `:before` 和 `:after` 伪元素的。

如果你想为图片添加装饰或额外的图形元素，你可以使用一个容器元素（比如 `div`），然后将 `img` 元素放入该容器内。之后，你可以对这个容器使用 `:before` 或 `:after` 伪元素来添加装饰内容。

例如，以下HTML和CSS代码演示了如何给图片添加一个简单的装饰边框：

```html
<div class="image-container">
  <img src="example.jpg" alt="示例图片" />
</div>
```

```css
.image-container {
  position: relative;
  display: inline-block;
}

.image-container:before {
  content: "";
  position: absolute;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  border: 2px solid red;
  pointer-events: none; /* 防止伪元素捕获鼠标事件 */
}
```

在这个例子中，`.image-container` 就像是 `img` 的父容器，我们可以在它上面使用 `:before` 伪元素来创建一个边框效果，而这个边框会显示在图片的周围。
这种方法允许开发者在图片周围添加虚拟的内容，比如边框、背景或者其他装饰物，而无需修改原始的 `img` 标签。这样的技术可以保持HTML结构的清晰和语义化，同时还能提供灵活的样式设计。

例如，如果你想给图片添加一个悬浮时显示的标题或标签，你可以这样做：

```html
<div class="image-wrapper">
  <img src="example.jpg" alt="示例图片" />
</div>
```

```css
.image-wrapper {
  position: relative;
  display: inline-block;
}

.image-wrapper:before {
  content: "图片标题";
  position: absolute;
  bottom: 0;
  left: 0;
  padding: 5px;
  color: white;
  background-color: rgba(0, 0, 0, 0.7);
  width: 100%;
  opacity: 0;
  transition: opacity 0.3s ease;
  pointer-events: none;
}

.image-wrapper:hover:before {
  opacity: 1;
}
```

在上述代码中，当用户将鼠标悬浮在 `.image-wrapper` 包裹的图片上时，`before` 伪元素中定义的内容（"图片标题"）就会显示出来，作为图片的标题或者说明文字。这种方法同样不会影响到 `img` 元素本身，而是通过包裹元素和CSS伪元素来实现效果。

总的来说，对于不能直接应用 `:before` 和 `:after` 伪元素的替换元素，我们可以通过创造性的方法，例如使用包裹元素或者其他结构性的标签，来模拟出我们想要的效果。这样做的好处是不会对HTML的语义结构造成影响，同时还能保持样式的灵活性和扩展性。

CSS 为什么不能处理 img 元素的 before 伪元素？

在HTML中，超链接（`a` 标签）默认会有特定的颜色，通常未访问的链接是蓝色，而访问过的链接是紫色。如果你想要删除或者改变这些默认颜色，可以使用CSS。

以下是一个简单的CSS示例来改变链接颜色：

```css
/* 未访问的链接 */
a:link {
    color: inherit; /* 这将使链接颜色继承父元素的颜色 */
    text-decoration: none; /* 这将移除下划线 */
}

/* 访问过的链接 */
a:visited {
    color: inherit; /* 同上 */
    text-decoration: none; /* 同上 */
}

/* 鼠标悬停状态 */
a:hover {
    color: inherit; /* 你可以在这里设置悬停时的颜色，或者保持继承 */
    text-decoration: underline; /* 在悬停时显示下划线，这是可选的 */
}

/* 鼠标激活点击状态 */
a:active {
    color: inherit; /* 你可以在这里设置点击时的颜色，或者保持继承 */
    text-decoration: none;
}
```

这段CSS代码可以应用到你的HTML文档的`<head>`部分或者一个外部的CSS文件中。`inherit`值意味着链接的颜色将不再是浏览器默认的蓝色或紫色，而是会继承其父元素的字体颜色。`text-decoration: none;`用于移除链接的下划线，但你可以根据需要来调整这些属性。

例如，如果你的HTML文档中有一个段落，你希望其中的链接没有默认的蓝色或紫色，看起来就像普通文本一样，你可以这样做：

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <style>
        /* 这里是之前提供的CSS代码 */
        a:link, a:visited, a:hover, a:active {
            color: inherit;
            text-decoration: none;
        }
    </style>
</head>
<body>
    <p style="color: black;">这是一个段落，里面有一个<a href="https://www.example.com">链接</a>，它看起来应该和其他文本一样。</p>
</body>
</html>
```

在这个例子中，`<a>` 标签内的文本将显示为与周围文本相同的颜色，并且没有下划线，除非鼠标悬停在链接上时，你可以设置显示下划线。这样，链接看起来就和普通的文本没有区别了。

简言之，通过使用CSS，你可以轻松地改变或删除超链接的默认颜色和下划线，以符合你的设计需求。

继承[值](https://developer.mozilla.org/en-US/docs/Web/CSS/inherit)：

    a { color: inherit; } 
    

...将导致该元素呈现其父级的颜色（这就是我认为您正在寻找的）。

现场演示如下：

显示代码片段

    a {
      color: inherit;
    }

    <p>The default color of the html element is black. The default colour of the body and of a paragraph is inherited. This
      <a href="http://example.com">link</a> would normally take on the default link or visited color, but has been styled to inherit the color from the paragraph.</p>

Run code snippetHide results

Expand snippet

尝试这样的事情：

    a {
        color: #0060B6;
        text-decoration: none;
    }
    
    a:hover {
        color:#00A0C6; 
        text-decoration:none; 
        cursor:pointer;  
    }
    

如果`text-decoration`不起作用，请将其更改为：

    text-decoration: none !important;
    

该`!important`规则会覆盖该属性的所有其他样式`text-decoration`。你可以[在这里](https://www.w3schools.com/css/css_important.asp)读更多关于它的内容。

如果您不想看到浏览器提供的下划线和默认颜色，可以将以下代码保留在 main.css 文件的顶部。如果您需要不同的颜色和装饰样式，您可以使用下面的代码片段轻松覆盖默认值。

     a, a:hover, a:focus, a:active {
          text-decoration: none;
          color: inherit;
     }

.cancela,.cancela:link,.cancela:visited,.cancela:hover,.cancela:focus,.cancela:active{
        color: inherit;
        text-decoration: none;
    }
    

我觉得有必要发布上面的类定义，SO上的许多答案都遗漏了一些状态

这也是可能的：

    a {
      all: unset;
    }
    

> unset：此关键字指示将应用于该元素或该元素的父元素的所有属性更改为它们的父值（如果它们是可继承的），否则更改为它们的初始值。 unicode-bidi 和方向值不受影响。

来源：[Mozilla 的所有描述](https://developer.mozilla.org/en-US/docs/Web/CSS/all)

在CSS中，您可以通过设置 `a` 标签的 `color` 属性来删除超链接的默认链接颜色。默认情况下，未访问的链接是蓝色的，而已访问的链接则是紫色的。如果您想要超链接看起来不像传统的链接，您可以指定一个颜色值，甚至可以将其设置为与文本相同的颜色。

以下是一段CSS代码，展示了如何为超链接设置不同状态下的颜色：

```css
/* 未访问的链接 */
a:link {
    color: black; /* 或者可以是任何颜色，例如#000000或者rgba(0,0,0,1) */
    text-decoration: none; /* 这会删除下划线 */
}

/* 已访问的链接 */
a:visited {
    color: black; /* 设置成和未访问链接一样的颜色 */
    text-decoration: none;
}

/* 鼠标悬浮在链接上 */
a:hover {
    color: gray; /* 或者你想要的任何颜色 */
    text-decoration: underline; /* 可选：鼠标悬浮时添加下划线 */
}

/* 鼠标点击链接的那一刻 */
a:active {
    color: red; /* 或者你想要的任何颜色 */
    text-decoration: none;
}
```

在上面的例子中，我将所有链接都设置成了黑色，并且移除了下划线，这样链接在视觉上就不再显示为传统的蓝色或紫色带下划线的文本。同时，我也添加了 `:hover` 和 `:active` 状态的样式，以便在用户与链接交互时提供视觉反馈。当然，您可以根据您的设计需求自由地修改这些属性值。

如何删除html超链接a标记的默认链接颜色

在 CSS 中，我们可以使用伪元素和伪类来自定义 HTML 元素的滚动条样式。对于一个 `div` 元素，我们可以通过针对 `::-webkit-scrollbar` 及其相关伪元素来设置样式，这样可以允许我们控制滚动条的不同部分，比如滚动条本身、滚动条轨道和滚动条的滑块（thumb）。

这里是一个简单的例子，展示了如何自定义一个 `div` 的滚动条：

```css
/* 选择器指向 div 的滚动条 */
div::-webkit-scrollbar {
  width: 12px; /* 设置滚动条宽度 */
  background-color: #F5F5F5; /* 设置滚动条的背景颜色 */
}

/* 滚动条轨道 */
div::-webkit-scrollbar-track {
  box-shadow: inset 0 0 5px grey; /* 在轨道内部加阴影效果 */
  border-radius: 10px; /* 设置轨道的圆角 */
}

/* 滚动条的滑块 */
div::-webkit-scrollbar-thumb {
  background: #888; /* 滑块颜色 */
  border-radius: 10px; /* 滑块圆角 */
}

/* 滑块悬浮效果 */
div::-webkit-scrollbar-thumb:hover {
  background: #555; /* 滑块悬浮时的颜色变化 */
}
```

在上面的例子中，`div` 元素的滚动条宽度被设置为12像素，并且有一个灰色的背景。滚动条轨道有一个内部阴影和圆角，而滚动条的滑块则有不同的背景色和圆角。当鼠标悬停在滑块上时，滑块的颜色会变成更深的灰色。

需要注意的是这些样式主要适用于基于 WebKit 的浏览器，如 Chrome、Safari 等。对于其他浏览器，比如 Firefox，你需要使用不同的伪元素 `scrollbar-width` 和 `scrollbar-color`：

```css
/* Firefox 的滚动条样式 */
div {
  scrollbar-width: thin; /* 可以是 'auto', 'thin', 'none' */
  scrollbar-color: #888 #F5F5F5; /* 滑块颜色 和 轨道颜色 */
}
```

在实际项目中，考虑到不同浏览器的兼容性，我们可能需要结合使用前面提到的 WebKit 特定选择器和适用于其他浏览器的 CSS 属性来确保尽可能多的用户可以看到自定义的滚动条样式。

最后，随着 Web 标准的不断发展，自定义滚动条的方法可能会随着时间而发展变化，所以在实际应用中，我们需要参考最新的 CSS 标准和不同浏览器的支持情况。

我认为整合有关滚动条、CSS 和浏览器兼容性的最新信息会很有帮助。

滚动条 CSS 支持
==========

目前，不存在跨浏览器滚动条 CSS 样式定义。我在最后提到的[W3C 文章](https://www.w3.org/Style/Examples/007/scrollbars.en.html)有以下声明，并且最近更新了（2014 年 10 月 10 日）：

> 某些浏览器（IE、Konqueror）支持非标准属性“scrollbar-shadow-color”、“scrollbar-track-color”等。**这些属性是非法的：它们既没有在任何 CSS 规范中定义，也没有标记为专有（通过在它们前面加上“-vendor-”前缀）**

微软
--

正如其他人提到的，微软支持滚动条样式，但仅适用于 IE8 及更高版本。

例子：

    .TA {
        scrollbar-3dlight-color:gold;
        scrollbar-arrow-color:blue;
        scrollbar-base-color:;
        scrollbar-darkshadow-color:blue;
        scrollbar-face-color:;
        scrollbar-highlight-color:;
        scrollbar-shadow-color:
    }
    

Chrome 和 Safari (WebKit)
------------------------

同样，WebKit 现在也有自己的版本：

*   样式滚动条：[https://www.webkit.org/blog/363/styling-scrollbars/](https://www.webkit.org/blog/363/styling-scrollbars/)
    
*   [所有 WebKit 滚动条样式的演示](https://trac.webkit.org/export/41842/trunk/LayoutTests/scrollbars/overflow-scrollbar-combinations.html)
    
*   来自[WebKit 中的自定义滚动条](https://css-tricks.com/custom-scrollbars-in-webkit/)，相关 CSS：
    
         /* pseudo elements */
         ::-webkit-scrollbar              {  }
         ::-webkit-scrollbar-button       {  }
         ::-webkit-scrollbar-track        {  }
         ::-webkit-scrollbar-track-piece  {  }
         ::-webkit-scrollbar-thumb        {  }
         ::-webkit-scrollbar-corner       {  }
         ::-webkit-resizer                {  }
        
         /* pseudo class selectors */
         :horizontal
         :vertical
         :decrement
         :increment
         :start
         :end 
         :double-button
         :single-button
         :no-button
         :corner-present
         :window-inactive
        
    

火狐（壁虎）
------

从版本 64 开始，Firefox 通过属性`scrollbar-color`（部分为[W3C 草案](https://drafts.csswg.org/css-scrollbars-1/#scrollbar-color)）和`scrollbar-width`（[W3C 草案](https://drafts.csswg.org/css-scrollbars-1/#scrollbar-width)）支持滚动条样式。有关实施的一些有用信息可以在[此答案](https://stackoverflow.com/a/54101063/6396604)中找到。

跨浏览器滚动条样式
=========

JavaScript 库和插件可以提供跨浏览器解决方案。有很多选择。

*   [20 jQuery 滚动条插件示例](http://www.bestjquery.com/2012/07/jquery-scrollbar-plugin-examples/)（2012 年 7 月 24 日）
    *   [NiceScroll：适用于桌面、移动和触摸设备的 jQuery 滚动插件](https://code.google.com/p/jquery-nicescroll/)
    *   [jQuery 自定义内容滚动条](http://manos.malihu.gr/jquery-custom-content-scroller/)
    *   [Tiny Scrollbar – 一个轻量级的 jQuery 插件](http://www.bestjquery.com/?8OKI7cdR)
    *   ETC。
*   [30 多种用于滑块、滚动条和滚动条的 JavaScript/Ajax 技术](http://www.noupe.com/javascript/30-javascriptajax-techniques-for-sliders-scrollers-and-scrollbars.html)（2008 年 5 月 7 日）
*   [21 个有用的滚动条 CSS/JavaScript 样式教程](http://ginva.com/2012/08/21-useful-scrollbar-css-javascript-styling-tutorials/)（2012 年 8 月）
*   [15+ 个免费和高级 jQuery 滚动插件](http://designmodo.com/jquery-scrolling-plugins/)（2012 年 8 月 26 日）

这份名单可以继续使用。最好的选择是搜索、研究和测试可用的解决方案。我相信您一定能找到适合您需求的东西。

防止非法滚动条样式
=========

万一您想阻止未正确添加“-vendor”前缀的滚动条样式，[W3C 上的这篇文章提供了一些基本说明](https://www.w3.org/Style/Examples/007/scrollbars.en.html)。基本上，您需要将以下 CSS 添加到与您的浏览器关联的用户样式表中。这些定义将覆盖您访问的任何页面上无效的滚动条样式。

    body, html {
      scrollbar-face-color: ThreeDFace !important;
      scrollbar-shadow-color: ThreeDDarkShadow !important;
      scrollbar-highlight-color: ThreeDHighlight !important;
      scrollbar-3dlight-color: ThreeDLightShadow !important;
      scrollbar-darkshadow-color: ThreeDDarkShadow !important;
      scrollbar-track-color: Scrollbar !important;
      scrollbar-arrow-color: ButtonText !important;
    }
    

重复或类似的问题/上面未链接的来源
=================

*   [更改滚动条的样式](https://stackoverflow.com/questions/3203107/changing-the-scrollbars-style)
*   [CSS滚动条样式跨浏览器](https://stackoverflow.com/questions/7725652/css-scrollbar-style-cross-browser)
*   [如何在 div 上创建自定义滚动条（Facebook 风格）](https://stackoverflow.com/questions/9945547/how-to-create-a-custom-scrollbar-on-a-div)

**注意：**此答案包含来自各种来源的信息。如果使用了来源，那么它也会在此答案中链接。

尝试一下

来源： https: [//nicescroll.areaaperta.com/](https://nicescroll.areaaperta.com/)

实施简单

    <script type="text/javascript">
     $(document).ready(
    
      function() { 
    
        $("html").niceScroll();
    
      }
    
    );
    </script>
    

它是一个 jQuery 插件滚动条，因此您的滚动条是可控的，并且在各种操作系统中看起来都相同。

请检查此链接：  
[CSS 滚动条](https://codepen.io/GhostRider/pen/GHaFw)

工作演示示例

        #style-1::-webkit-scrollbar-track
        {
            -webkit-box-shadow: inset 0 0 6px rgba(0,0,0,0.3);
            border-radius: 10px;
            background-color: #F5F5F5;
        }
        
        #style-1::-webkit-scrollbar
        {
            width: 12px;
            background-color: #F5F5F5;
        }
        
        #style-1::-webkit-scrollbar-thumb
        {
            border-radius: 10px;
            -webkit-box-shadow: inset 0 0 6px rgba(0,0,0,.3);
            background-color: #555;
        }

CSS 无法实现自定义滚动条，您需要一些 JavaScript 魔法。

某些浏览器支持非规范 CSS 规则，例如`::-webkit-scrollbar`在 Webkit 中，但并不理想，因为它只能在 Webkit 中工作。 IE 也有类似的东西，但我认为他们不再支持它了。

像许多人一样，我一直在寻找以下东西：

*   在大多数现代浏览器中保持一致的样式和功能
*   不是一些可笑的 3000 行臃肿的 jQuery 扩展 cr\*p

...但是唉——什么也没有！

好吧，如果一项工作值得做……我就能在大约 30 分钟内启动并运行一些东西。免责声明：它有很多已知的（可能还有一些未知的）问题，但这让我想知道在许多产品中其他 2920 行 JS 到底有什么用！

    (window => {
    
      let initCoords;
    
      const coords_update = e => {
        if (initCoords) {
          const elem = initCoords.bar.closest('.scrollr');
          const eSuffix = initCoords.axis.toUpperCase();
          const sSuffix = initCoords.axis == 'x' ? 'Left' : 'Top';
          const dSuffix = initCoords.axis == 'x' ? 'Width' : 'Height';
          const max = elem['scroll' + dSuffix] - elem['client' + dSuffix];
          const room = elem['client' + dSuffix] - initCoords.bar['client' + dSuffix];
          const delta = e['page' + eSuffix] - initCoords.abs;
          const abs = initCoords.p0 + delta;
          elem['scroll' + sSuffix] = max * abs / room;
        }
      };
    
      const scrollr_resize = elem => {
        const xBar = elem.querySelector('.track.x .bar');
        const yBar = elem.querySelector('.track.y .bar');
        const xRel = elem.clientWidth / elem.scrollWidth;
        const yRel = elem.clientHeight / elem.scrollHeight;
        xBar.style.width = (100 * xRel).toFixed(2) + '%';
        yBar.style.height = (100 * yRel).toFixed(2) + '%';
      };
    
      const scrollr_init = elem => {
        const xTrack = document.createElement('span');
        const yTrack = document.createElement('span');
        const xBar = document.createElement('span');
        const yBar = document.createElement('span');
        xTrack.className = 'track x';
        yTrack.className = 'track y';
        xBar.className = 'bar';
        yBar.className = 'bar';
        xTrack.appendChild(xBar);
        yTrack.appendChild(yBar);
        elem.appendChild(xTrack);
        elem.appendChild(yTrack);
        elem.addEventListener('wheel', scrollr_OnWheel);
        elem.addEventListener('scroll', scrollr_OnScroll);
        xTrack.addEventListener('wheel', xTrack_OnWheel);
        xTrack.addEventListener('click', xTrack_OnClick);
        xTrack.addEventListener('mouseover', () => xTrack.classList.add('active'));
        xTrack.addEventListener('mouseout', () => {
          if (!initCoords) xTrack.classList.remove('active');
        });
        yTrack.addEventListener('click', yTrack_OnClick);
        yTrack.addEventListener('mouseover', () => yTrack.classList.add('active'));
        yTrack.addEventListener('mouseout', () => {
          if (!initCoords) yTrack.classList.remove('active');
        });
        xBar.addEventListener('click', bar_OnClick);
        xBar.addEventListener('mousedown', xBar_OnMouseDown);
        yBar.addEventListener('click', bar_OnClick);
        yBar.addEventListener('mousedown', yBar_OnMouseDown);
    
        scrollr_resize(elem);
      };
    
      window.addEventListener('load', e => {
        const scrollrz = Array.from(document.querySelectorAll('.scrollr'));
        scrollrz.forEach(scrollr_init);
      });
    
      window.addEventListener('resize', e => {
        const scrollrz = Array.from(document.querySelectorAll('.scrollr'));
        scrollrz.forEach(scrollr_resize);
      });
    
      window.addEventListener('mousemove', coords_update);
      window.addEventListener('mouseup', e => {
        initCoords = null;
        Array.from(document.querySelectorAll('.track.active'))
          .forEach(elem => elem.classList.remove('active'));
      });
    
      function xBar_OnMouseDown(e) {
        const p0 = this.offsetLeft;
        initCoords = {
          axis: 'x',
          abs: e.pageX,
          bar: this,
          p0
        };
      }
    
      function yBar_OnMouseDown(e) {
        const p0 = this.offsetTop;
        initCoords = {
          axis: 'y',
          abs: e.pageY,
          bar: this,
          p0
        };
      }
    
      function bar_OnClick(e) {
        e.stopPropagation();
      }
    
      function xTrack_OnClick(e) {
        const elem = this.closest('.scrollr');
        const xBar = this.querySelector('.bar');
        let unit = elem.clientWidth - 30;
        if (e.offsetX <= xBar.offsetLeft) unit *= -1;
        elem.scrollLeft += unit;
      }
    
      function yTrack_OnClick(e) {
        const elem = this.closest('.scrollr');
        const yBar = this.querySelector('.bar');
        let unit = elem.clientHeight - 30;
        if (e.offsetY <= yBar.offsetTop) unit *= -1;
        elem.scrollTop += unit;
      }
    
      function xTrack_OnWheel(e) {
        e.stopPropagation();
        const elem = this.closest('.scrollr');
        const left0 = elem.scrollLeft;
        const delta = e.deltaY !== 0 ? e.deltaY : e.deltaX;
        elem.scrollLeft += delta;
        const moved = left0 !== elem.scrollLeft;
        if (moved) e.preventDefault();
      }
    
      function scrollr_OnWheel(e) {
        const left0 = this.scrollLeft;
        const top0 = this.scrollTop;
        this.scrollLeft += e.deltaX;
        this.scrollTop += e.deltaY;
        const moved = left0 !== this.scrollLeft || top0 !== this.scrollTop;
        if (moved) e.preventDefault();
      }
    
      function scrollr_OnScroll(e) {
        const xTrack = this.querySelector('.track.x');
        const yTrack = this.querySelector('.track.y');
        const xBar = xTrack.querySelector('.bar');
        const yBar = yTrack.querySelector('.bar');
    
        const xMax = this.scrollWidth - this.clientWidth;
        const yMax = this.scrollHeight - this.clientHeight;
        const xFrac = this.scrollLeft / xMax;
        const yFrac = this.scrollTop / yMax;
        const xAbs = xFrac * (this.clientWidth - xBar.clientWidth);
        const yAbs = yFrac * (this.clientHeight - yBar.clientHeight);
    
        xTrack.style.left = this.scrollLeft + 'px';
        xTrack.style.bottom = -this.scrollTop + 'px';
        xBar.style.left = xAbs + 'px';
    
        yTrack.style.top = this.scrollTop + 'px';
        yTrack.style.right = -this.scrollLeft + 'px';
        yBar.style.top = yAbs + 'px';
      };
    
    })(window);

    .scrollr {
      overflow: hidden;
      position: relative;
    }
    
    .track {
      position: absolute;
      cursor: pointer;
      transition: background-color .3s;
      user-select: none;
    }
    
    .track.x {
      left: 0;
      bottom: 0;
      width: 100%;
      height: 10px;
    }
    
    .track.y {
      top: 0;
      right: 0;
      height: 100%;
      width: 10px;
    }
    
    .bar {
      position: absolute;
      background-color: yellow;
      transition: background-color .3s, opacity .3s, width .3s, height .3s, margin .3s;
      display: block;
      width: 100%;
      height: 100%;
      opacity: .7;
    }
    
    .track.x .bar {
      min-width: 25px;
      height: 3px;
      margin: 5px 0 2px 0;
    }
    
    .track.y .bar {
      min-height: 25px;
      width: 3px;
      margin: 0 2px 0 5px;
    }
    
    .track.active {
      background-color: #ccc;
    }
    
    .track.active .bar {
      background-color: #999;
      margin: 0;
      opacity: 1;
    }
    
    .track.x.active .bar {
      height: 10px;
    }
    
    .track.y.active .bar {
      width: 10px;
    }
    
    
    /* Custom client stuff */
    
    .content {
      background: red;
    }
    
    .content p {
      width: 450px;
      margin: 0;
    }
    
    .scrollr {
      max-width: 350px;
      max-height: 150px;
    }

    <div class="scrollr content">
      <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc diam magna, molestie sit amet auctor nec, dictum quis mi. Duis pellentesque lacinia pretium. Donec pulvinar, risus sit amet dapibus mattis, eros urna bibendum elit, vel mollis sapien arcu
        vitae mi. Fusce vulputate vestibulum metus dapibus eleifend. Quisque ut dictum orci. Nunc bibendum, sapien ac condimentum placerat, arcu orci mollis nunc, vitae sollicitudin arcu nulla quis enim. Praesent non tellus vitae quam tempor maximus vel sed
        dolor. Donec id ante ultricies, iaculis sem ut, sollicitudin enim. Quisque id mauris est. Maecenas viverra urna vitae velit semper, vel ultricies augue feugiat. Pellentesque in libero porttitor, lacinia metus in, maximus nisi. Phasellus commodo ligula
        vel arcu iaculis hendrerit vitae vel diam. Sed sed lorem maximus, vestibulum leo ut, posuere libero. Donec arcu dui, euismod id aliquet sed, porttitor vitae elit.</p>
      <p>Sed aliquam eget justo sit amet dictum. Suspendisse potenti. In placerat orci quis vehicula vehicula. Proin tempor laoreet suscipit. Proin non nulla lacinia est ullamcorper maximus et a sem. Nulla at lacus rhoncus, malesuada ante in, imperdiet sem.
        Mauris convallis tristique metus in iaculis. Nulla laoreet ligula non interdum tincidunt. Morbi sed venenatis arcu, sed gravida est. Fusce malesuada ullamcorper lacus, in vulputate risus finibus non.</p>
      <p>Suspendisse sapien leo, auctor non ex vitae, volutpat laoreet tortor. Suspendisse sodales libero velit, sed pulvinar lectus feugiat vel. Sed erat eros, porttitor id enim nec, ornare hendrerit nibh. Phasellus at nisi lectus. Cras semper lobortis condimentum.
        Etiam nunc felis, vehicula vitae tincidunt pellentesque, pretium sit amet dui. Duis aliquet ultrices lacus eget efficitur. Ut imperdiet velit sed enim laoreet, sed semper libero hendrerit. Donec malesuada auctor sollicitudin.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc diam magna, molestie sit amet auctor nec, dictum quis mi. Duis pellentesque lacinia pretium. Donec pulvinar, risus sit amet dapibus mattis, eros urna bibendum elit, vel mollis sapien arcu
        vitae mi. Fusce vulputate vestibulum metus dapibus eleifend. Quisque ut dictum orci. Nunc bibendum, sapien ac condimentum placerat, arcu orci mollis nunc, vitae sollicitudin arcu nulla quis enim. Praesent non tellus vitae quam tempor maximus vel sed
        dolor. Donec id ante ultricies, iaculis sem ut, sollicitudin enim. Quisque id mauris est. Maecenas viverra urna vitae velit semper, vel ultricies augue feugiat. Pellentesque in libero porttitor, lacinia metus in, maximus nisi. Phasellus commodo ligula
        vel arcu iaculis hendrerit vitae vel diam. Sed sed lorem maximus, vestibulum leo ut, posuere libero. Donec arcu dui, euismod id aliquet sed, porttitor vitae elit.</p>
      <p>Sed aliquam eget justo sit amet dictum. Suspendisse potenti. In placerat orci quis vehicula vehicula. Proin tempor laoreet suscipit. Proin non nulla lacinia est ullamcorper maximus et a sem. Nulla at lacus rhoncus, malesuada ante in, imperdiet sem.
        Mauris convallis tristique metus in iaculis. Nulla laoreet ligula non interdum tincidunt. Morbi sed venenatis arcu, sed gravida est. Fusce malesuada ullamcorper lacus, in vulputate risus finibus non.</p>
      <p>Suspendisse sapien leo, auctor non ex vitae, volutpat laoreet tortor. Suspendisse sodales libero velit, sed pulvinar lectus feugiat vel. Sed erat eros, porttitor id enim nec, ornare hendrerit nibh. Phasellus at nisi lectus. Cras semper lobortis condimentum.
        Etiam nunc felis, vehicula vitae tincidunt pellentesque, pretium sit amet dui. Duis aliquet ultrices lacus eget efficitur. Ut imperdiet velit sed enim laoreet, sed semper libero hendrerit. Donec malesuada auctor sollicitudin.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc diam magna, molestie sit amet auctor nec, dictum quis mi. Duis pellentesque lacinia pretium. Donec pulvinar, risus sit amet dapibus mattis, eros urna bibendum elit, vel mollis sapien arcu
        vitae mi. Fusce vulputate vestibulum metus dapibus eleifend. Quisque ut dictum orci. Nunc bibendum, sapien ac condimentum placerat, arcu orci mollis nunc, vitae sollicitudin arcu nulla quis enim. Praesent non tellus vitae quam tempor maximus vel sed
        dolor. Donec id ante ultricies, iaculis sem ut, sollicitudin enim. Quisque id mauris est. Maecenas viverra urna vitae velit semper, vel ultricies augue feugiat. Pellentesque in libero porttitor, lacinia metus in, maximus nisi. Phasellus commodo ligula
        vel arcu iaculis hendrerit vitae vel diam. Sed sed lorem maximus, vestibulum leo ut, posuere libero. Donec arcu dui, euismod id aliquet sed, porttitor vitae elit.</p>
      <p>Sed aliquam eget justo sit amet dictum. Suspendisse potenti. In placerat orci quis vehicula vehicula. Proin tempor laoreet suscipit. Proin non nulla lacinia est ullamcorper maximus et a sem. Nulla at lacus rhoncus, malesuada ante in, imperdiet sem.
        Mauris convallis tristique metus in iaculis. Nulla laoreet ligula non interdum tincidunt. Morbi sed venenatis arcu, sed gravida est. Fusce malesuada ullamcorper lacus, in vulputate risus finibus non.</p>
      <p>Suspendisse sapien leo, auctor non ex vitae, volutpat laoreet tortor. Suspendisse sodales libero velit, sed pulvinar lectus feugiat vel. Sed erat eros, porttitor id enim nec, ornare hendrerit nibh. Phasellus at nisi lectus. Cras semper lobortis condimentum.
        Etiam nunc felis, vehicula vitae tincidunt pellentesque, pretium sit amet dui. Duis aliquet ultrices lacus eget efficitur. Ut imperdiet velit sed enim laoreet, sed semper libero hendrerit. Donec malesuada auctor sollicitudin.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc diam magna, molestie sit amet auctor nec, dictum quis mi. Duis pellentesque lacinia pretium. Donec pulvinar, risus sit amet dapibus mattis, eros urna bibendum elit, vel mollis sapien arcu
        vitae mi. Fusce vulputate vestibulum metus dapibus eleifend. Quisque ut dictum orci. Nunc bibendum, sapien ac condimentum placerat, arcu orci mollis nunc, vitae sollicitudin arcu nulla quis enim. Praesent non tellus vitae quam tempor maximus vel sed
        dolor. Donec id ante ultricies, iaculis sem ut, sollicitudin enim. Quisque id mauris est. Maecenas viverra urna vitae velit semper, vel ultricies augue feugiat. Pellentesque in libero porttitor, lacinia metus in, maximus nisi. Phasellus commodo ligula
        vel arcu iaculis hendrerit vitae vel diam. Sed sed lorem maximus, vestibulum leo ut, posuere libero. Donec arcu dui, euismod id aliquet sed, porttitor vitae elit.</p>
      <p>Sed aliquam eget justo sit amet dictum. Suspendisse potenti. In placerat orci quis vehicula vehicula. Proin tempor laoreet suscipit. Proin non nulla lacinia est ullamcorper maximus et a sem. Nulla at lacus rhoncus, malesuada ante in, imperdiet sem.
        Mauris convallis tristique metus in iaculis. Nulla laoreet ligula non interdum tincidunt. Morbi sed venenatis arcu, sed gravida est. Fusce malesuada ullamcorper lacus, in vulputate risus finibus non.</p>
      <p>Suspendisse sapien leo, auctor non ex vitae, volutpat laoreet tortor. Suspendisse sodales libero velit, sed pulvinar lectus feugiat vel. Sed erat eros, porttitor id enim nec, ornare hendrerit nibh. Phasellus at nisi lectus. Cras semper lobortis condimentum.
        Etiam nunc felis, vehicula vitae tincidunt pellentesque, pretium sit amet dui. Duis aliquet ultrices lacus eget efficitur. Ut imperdiet velit sed enim laoreet, sed semper libero hendrerit. Donec malesuada auctor sollicitudin.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc diam magna, molestie sit amet auctor nec, dictum quis mi. Duis pellentesque lacinia pretium. Donec pulvinar, risus sit amet dapibus mattis, eros urna bibendum elit, vel mollis sapien arcu
        vitae mi. Fusce vulputate vestibulum metus dapibus eleifend. Quisque ut dictum orci. Nunc bibendum, sapien ac condimentum placerat, arcu orci mollis nunc, vitae sollicitudin arcu nulla quis enim. Praesent non tellus vitae quam tempor maximus vel sed
        dolor. Donec id ante ultricies, iaculis sem ut, sollicitudin enim. Quisque id mauris est. Maecenas viverra urna vitae velit semper, vel ultricies augue feugiat. Pellentesque in libero porttitor, lacinia metus in, maximus nisi. Phasellus commodo ligula
        vel arcu iaculis hendrerit vitae vel diam. Sed sed lorem maximus, vestibulum leo ut, posuere libero. Donec arcu dui, euismod id aliquet sed, porttitor vitae elit.</p>
      <p>Sed aliquam eget justo sit amet dictum. Suspendisse potenti. In placerat orci quis vehicula vehicula. Proin tempor laoreet suscipit. Proin non nulla lacinia est ullamcorper maximus et a sem. Nulla at lacus rhoncus, malesuada ante in, imperdiet sem.
        Mauris convallis tristique metus in iaculis. Nulla laoreet ligula non interdum tincidunt. Morbi sed venenatis arcu, sed gravida est. Fusce malesuada ullamcorper lacus, in vulputate risus finibus non.</p>
      <p>Suspendisse sapien leo, auctor non ex vitae, volutpat laoreet tortor. Suspendisse sodales libero velit, sed pulvinar lectus feugiat vel. Sed erat eros, porttitor id enim nec, ornare hendrerit nibh. Phasellus at nisi lectus. Cras semper lobortis condimentum.
        Etiam nunc felis, vehicula vitae tincidunt pellentesque, pretium sit amet dui. Duis aliquet ultrices lacus eget efficitur. Ut imperdiet velit sed enim laoreet, sed semper libero hendrerit. Donec malesuada auctor sollicitudin.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc diam magna, molestie sit amet auctor nec, dictum quis mi. Duis pellentesque lacinia pretium. Donec pulvinar, risus sit amet dapibus mattis, eros urna bibendum elit, vel mollis sapien arcu
        vitae mi. Fusce vulputate vestibulum metus dapibus eleifend. Quisque ut dictum orci. Nunc bibendum, sapien ac condimentum placerat, arcu orci mollis nunc, vitae sollicitudin arcu nulla quis enim. Praesent non tellus vitae quam tempor maximus vel sed
        dolor. Donec id ante ultricies, iaculis sem ut, sollicitudin enim. Quisque id mauris est. Maecenas viverra urna vitae velit semper, vel ultricies augue feugiat. Pellentesque in libero porttitor, lacinia metus in, maximus nisi. Phasellus commodo ligula
        vel arcu iaculis hendrerit vitae vel diam. Sed sed lorem maximus, vestibulum leo ut, posuere libero. Donec arcu dui, euismod id aliquet sed, porttitor vitae elit.</p>
      <p>Sed aliquam eget justo sit amet dictum. Suspendisse potenti. In placerat orci quis vehicula vehicula. Proin tempor laoreet suscipit. Proin non nulla lacinia est ullamcorper maximus et a sem. Nulla at lacus rhoncus, malesuada ante in, imperdiet sem.
        Mauris convallis tristique metus in iaculis. Nulla laoreet ligula non interdum tincidunt. Morbi sed venenatis arcu, sed gravida est. Fusce malesuada ullamcorper lacus, in vulputate risus finibus non.</p>
      <p>Suspendisse sapien leo, auctor non ex vitae, volutpat laoreet tortor. Suspendisse sodales libero velit, sed pulvinar lectus feugiat vel. Sed erat eros, porttitor id enim nec, ornare hendrerit nibh. Phasellus at nisi lectus. Cras semper lobortis condimentum.
        Etiam nunc felis, vehicula vitae tincidunt pellentesque, pretium sit amet dui. Duis aliquet ultrices lacus eget efficitur. Ut imperdiet velit sed enim laoreet, sed semper libero hendrerit. Donec malesuada auctor sollicitudin.</p>
    </div>

运行代码片段Hide results

展开片段

CSS相关问题