css - Inheritance


css 盒模型（Box Model）是指在网页中，每个 HTML 元素都可以看作是一个矩形的盒子，这个盒子有四个边界，分别是：内容区（content）、内边距（padding）、边框（border）和外边距（margin）。这四个边界分别对应了 HTML 元素的不同属性，通过这些属性的设置，我们可以控制盒子的大小、边框、内外边距等特征，从而实现布局和样式的控制。

下面对盒模型的四个部分进行详细解释：

1. 内容区（content）
   内容区是指 HTML 元素的实际内容，即文本、图像、视频、音频等。我们可以通过设置 width 和 height 属性来控制内容区的尺寸。

2. 内边距（padding）
   内边距是指内容区和边框之间的距离，也就是内容区的内部空白区域。我们可以通过设置 padding 属性来控制内边距的大小。padding 属性可以设置为一个值，表示四个方向的内边距大小都相等，也可以分别设置为四个值，表示各个方向的内边距大小不同。

3. 边框（border）
   边框是包围内容区和内边距的线条，我们可以通过设置 border 属性来控制边框的样式、粗细和颜色等。border 属性可以分别设置为三个值或四个值，分别表示边框的样式、粗细和颜色，以及边框的位置（上、右、下、左）。

4. 外边距（margin）
   外边距是指边框和相邻元素之间的距离，也就是元素的外部空白区域。我们可以通过设置 margin 属性来控制外边距的大小。margin 属性可以设置为一个值，表示四个方向的外边距大小都相等，也可以分别设置为四个值，表示各个方向的外边距大小不同。

盒模型分为标准盒模型和 IE 盒模型。

## 标准盒模型

标准盒模型是有`width`、`height`、`margin`、`padding`、`border`计算的。

标准盒模型的内容高度为 content+padding+border。

![WZbkTO](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/WZbkTO.jpg)

## IE 盒模型

与标准盒模型不同的是，IE 盒模型的内容高度为 content+padding。不包含 border。

![9MaHAJ](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/9MaHAJ.jpg)

## box-sizing

`box-sizing`是一个属性，它指定了内容高度的计算方式。

- content-box: 内容高度为 content+padding+border。
- border-box: 内容高度为 content+padding。

总之，css 盒模型提供了一种灵活的方式来控制 HTML 元素的大小、位置和样式。通过设置内容区、内边距、边框和外边距的属性，我们可以实现各种布局效果，从而达到设计的要求。


css 显示的所有对象都是盒模型。因此，了解 css 方框模型的工作原理是 css 的核心基础。

css - 盒模型


## 创建类

`Class`和`Struct`类似，但是类可以继承其他类，并且类可以定义属性和方法。

```swift
class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}

#创建实例
let poppy = Dog(name: "Poppy", breed: "Poodle")
```

## 类继承

和`Struct`不同的是，`Class`可以继承其他类。

```swift
class Poodle: Dog {
    init(name: String) {
        super.init(name: name, breed: "Poodle")
    }
}

super.init(name: name, breed: "Poodle") // 调用父类的构造器
```

## 方法重写

类创建的实例可以重写父类的方法。

```swift
class Dog {
    func bark() {
        print("Woof!")
    }
}

let poppy = Dog()
poppy.bark()

# 类继承重写方法
class Poodle: Dog {
    override func bark() {
        print("Yip!")
    }
}
```

## final 类

`Swift`提供关键词`final`来防止类被继承。

```swift
fina class Dog {
    func bark() {
        print("Woof!")
    }
}
```

## 复制 objects

与`Struct`不同的是，`Class`可以被复制。

```swift
class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}
var poppy = Dog(name: "Poppy", breed: "Poodle")
var poppyCopy = poppy
poppyCopy.name = "Poppy Copy"
```

## 反初始化

与`Struct`不同的是，`Class`可以被反初始化。

```swift
class Person {
    var name: String

    init(name: String) {
        self.name = name
    }

    func sayHello() {
        print("Hello, \(name)!")
    }
}
```

在循环中创建实例，可以使用`deinit`来定义反初始化方法。

```swift
for _ in 1...10 {
    let person = Person(name: "John")
    person.sayHello()
}

deinit {
    print("Goodbye, \(name)!")
}
```

## 可变性

类与结构在常量的处理方式上有所不同。如果一个类或结构体的实例被声明为常量，则该实例的所有属性也必须是常量。

```swift
class Person {
    var name = "Taylor Swift"
}
let person = Person()
person.name = "Justin Bieber"
print(person.name) // Justin Bieber

# 如果将类或结构体实例设置为常量，则不能修改实例的属性。
class Person {
    let name = "Taylor Swift"
}
```

## 总结

- `Class`和`Struct`是相似的，都可以使用属性和方法创建。
- 类可以继承其他类，并获得父类的所有属性和方法。
- 使用`final`来防止类被继承。
- 可以重写父类的方法。
- 当不同变量指向同一个类实例，它们指向的是同一块内存，改变一个会改变另一个
- 可以被反初始化。
- 类的属性可以被声明为可变的，但是不能被声明为常量。


Swift 类是构建代码所用的一种通用且灵活的构造体。

Classes - 类


`Next.js` 内置了对环境变量的支持，让你可以执行以下操作：

- 使用 `.env.local` 加载环境变量
- 通过给环境变量添加 `NEXT_PUBLIC_` `前缀将环境变量暴露给浏览器

## 创建环境变量

```bash
DB_HOST=localhost
DB_USR=root
DB_PWD=123456
```

## 创建 env.js

```jsx
import Head from 'next/head'
import Container from '../../components/container'

export default function FirstPost(props) {
  return (
    <>
      <Container>
        <Head>
          <title>Environment Variables</title>
        </Head>
        <h1>Database Credentials</h1>
        <p>Host: {props.host}</p>
        <p>Username: {props.username}</p>
        <p>Password: {props.password}</p>
      </Container>
    </>
  )
}

export async function getStaticProps() {
  // Connect to Database using DB properties
  return {
    props: {
      host: process.env.DB_HOST,
      username: process.env.DB_USER,
      password: process.env.DB_PASS
    }
  }
}
```

`Next.js`会在`.env*`中自动扩展变量，即可以定义变量

```bash
HOSTNAME=localhost
PORT=3000
HOST=http://$HOSTNAME:$PORT
```


Next.js 内置了对环境变量的支持

Next.js - Environment Variables


**export**用于设置或显示环境变量。

## 使用方法

```bash
export TEST="test"
# TEST代表变量名，test代表变量值

export -n TEST
#-n参数代表一出TEST变量
```

## 参数：

- -f 　代表[变量名称]中为函数名称。
- -n 　删除指定的变量。变量实际上并未删除，只是不会输出到后续指令的执行环境中。
- -p 　列出所有的 shell 赋予程序的环境变量。


export用于设置或显示环境变量。

Linux命令export


## 屏幕

### 屏幕大小

> 屏幕尺寸是屏幕的宽度和高度: 显示器、手机等设备屏幕。

![Screen Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/OrJAie.jpg)

`window.screen` 属性可以获取屏幕尺寸，其中包含屏幕的宽度和高度，以像素为单位。

```js
const screenWidth = window.screen.width
const screenHeight = window.screen.height
```

### 可用屏幕大小

> 可用屏幕尺寸是屏幕的宽度和高度，不包含任何系统窗口，以像素为单位。

![Available Screen Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/nYbW0L.jpg)

```js
const availableScreenWidth = window.screen.availWidth
const availableScreenHeight = window.screen.availHeight
```

## 视窗

### 视窗外部宽高

> 窗口的外部大小由整个浏览器窗口的宽度和高度组成，包括地址栏、标签栏和其他浏览器面板。

![Window Outer Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/8muma1.jpg)

使用`outerWidth`和`outerHeight`可以获取窗口的外部宽高，以像素为单位。

```js
const windowOuterWidth = window.outerWidth
const windowOuterHeight = window.outerHeight
```

### 视窗内部大小

> 视窗的内部大小由整个浏览器窗口的宽度和高度组成，不包括地址栏、标签栏和其他浏览器面板。

![Window Inner Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/YHT2o8.jpg)

使用`innerWidth`和`innerHeight`可以获取窗口的内部宽高，以像素为单位。

```js
const windowInnerWidth = window.innerWidth
const windowInnerHeight = window.innerHeight

/*不包含滚动条*/
const windowInnerWidth = document.documentElement.clientWidth
const windowInnerHeight = document.documentElement.clientHeight
```

## 页面大小

> 页面大小是页面内容的宽度和高度(不包含边框、边距和滚动条)。

![Page Size](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/Bk8qhy.jpg)

```js
const pageWidth = document.documentElement.scrollWidth
const pageHeight = document.documentElement.scrollHeight
// 如果 pageHeight 大于 window.innerHeight，则页面会出现横向滚动条
```


如何获取 Screen、Window、Page 等组件的宽高？


CSS 中的权重（specificity）是用来确定在多个 CSS 规则中，哪个规则的样式应该优先被应用的一种机制。权重是由不同类型的选择器组成的值，通常用一个四元组（a, b, c, d）来表示，其中：

- a 代表内联样式（inline styles），它的值为 1。
- b 代表 ID 选择器（id selectors），它的值为 ID 选择器的个数。
- c 代表类选择器（class selectors）、属性选择器（attribute selectors）和伪类选择器（pseudo-class selectors），它的值为这些选择器的个数之和。
- d 代表元素选择器（type selectors）和伪元素选择器（pseudo-element selectors），它的值为这些选择器的个数之和。

举个例子，如果一个 CSS 规则为：

```css
div#myId.myClass {
  color: red;
}
```

那么它的权重为 (0, 1, 1, 2)。

当多个 CSS 规则应用于同一个元素时，CSS 引擎会根据它们的权重来确定哪一个规则的样式应该被应用。具体来说，CSS 引擎会选择权重最高的规则。如果有多个规则的权重相同，则后定义的规则会覆盖先定义的规则。

需要注意的是，!important 关键字可以用来提高一个规则的权重。具体来说，它会给这个规则的权重添加一个极高的值，相当于 (0, 0, 0, ∞)。因此，一般情况下应该避免使用 !important，除非必须这样做。

以下是一些关于 CSS 权重的案例，用来帮助理解权重的计算方法和作用：

内联样式的权重最高，例如：

```html
<p style="color: red;">Hello, world!</p>
```

这个样式规则的权重为 (1, 0, 0, 0)，因此它的样式会优先于其他样式被应用。

ID 选择器的权重比类选择器和元素选择器高，例如：

```html
<div id="myDiv" class="myClass"></div>
```

```css
#myDiv.myClass {
  color: red;
}
```

这个样式规则的权重为 (0, 1, 1, 0)，因此它的样式优先于其他样式被应用。

选择器的权重是可以叠加的，例如：

```html
<p class="myClass"></p>
```

```css
p.myClass {
  color: red;
}
```

这个样式规则的权重为 (0, 0, 1, 1)，因为它包含了一个类选择器和一个元素选择器。

通配选择器和关系选择器的权重较低，例如：

```html
<div>
  <p>Hello, world!</p>
</div>
```

```css
div p {
  color: red;
}
```

这个样式规则的权重为 (0, 0, 0, 2)，因为它包含了两个元素选择器，但没有类选择器或 ID 选择器。因此，如果有一个包含类或 ID 选择器的规则也适用于这个元素，那么它的样式会优先于这个规则被应用。

!important 关键字会覆盖其他所有样式，例如：

```css
p {
  color: blue !important;
}

p {
  color: red;
}
```

即使第二个规则的权重更高，但由于第一个规则使用了 !important，因此它的样式会优先于第二个规则被应用。这也是为什么应该谨慎使用 !important 的原因。

总之，了解 CSS 权重机制对于编写高效、可维护的 CSS 代码非常重要，可以避免样式冲突和覆盖等问题。
