css选择器规定了css 规则会被应用到哪些元素上

css - Selectors


css 选择器规定了 css 规则会被应用到哪些元素上。

## 通用选择器

通用选择器选择命名空间所有的元素，如果未提供命名空间，则选择文档所有元素。

```css
* {
  margin: 0;
  padding: 0;
}

#app * {
  box-sizing: border-box;
}
```

## ID 选择器

ID 选择器选择具有指定 ID 属性的元素。

```css
#app {
  background: #fff;
}
```

## 类选择器

类选择器选择具有特定名称的元素，如果未提供类名，则选择所有元素。

```css
.app {
  color: red;
}
```

## 属性选择器

属性选择器选择具有指定属性的元素。

```css
input[type='text'] {
  border: 1px solid #ccc;
}
```

## 元素选择器

元素选择器选择具有指定名称的元素。

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

## 子元素选择器

子元素选择器选择具有指定名称的元素的所有子元素。

```css
#app > a {
  color: red;
}
```

## 伪类选择器

伪类选择器选择具有指定名称的元素，如果未提供伪类名，则选择所有元素。

```css
.app:hover {
  color: red;
}
.app:after {
  content: '.';
}
```

## 组合选择器

组合选择器选择具有指定名称的元素，如果未提供组合选择器，则选择所有元素。

```css
/*选择命名空间所有的div、p*/
div,
p {
  color: red;
}
/*选择命名空间所有的 li*/
ul > li {
  color: red;
}
/*选择临近的p*/
div + p {
  color: red;
}
```



Transitions（过渡）是一种 CSS 技术，可以在状态变化时平滑地改变元素的属性值，从而创建动画效果。过渡通常用于鼠标悬停、焦点变化或点击等用户交互事件。

过渡需要指定以下属性：

- transition-property：指定要应用过渡效果的 CSS 属性名称，可以是单个属性或多个属性的组合。
- transition-duration：指定过渡效果的持续时间，以秒或毫秒为单位。
- transition-timing-function：指定过渡效果的时间函数，控制过渡效果的速度和动画形式。常见的时间函数包括 ease、linear、ease-in、ease-out 和 ease-in-out。
- transition-delay：指定过渡效果的延迟时间，以秒或毫秒为单位。

例如，以下代码将在鼠标悬停时将按钮的背景颜色从白色变为灰色，并在 1 秒内平滑过渡：

```css
button {
  background-color: white;
  transition: background-color 1s ease;
}

button:hover {
  background-color: gray;
}
```

过渡还可以通过使用 CSS3 的 transform 和 opacity 属性来创建更复杂的动画效果。例如，以下代码将使元素在鼠标悬停时旋转 45 度，并在 1 秒内平滑过渡：

```css
div {
  transition: transform 1s ease;
}

div:hover {
  transform: rotate(45deg);
}
```


css - Transitions


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型。它返回左表中的所有行和右表中的所有行，包括在 ON 子句中不匹配的行。FULL OUTER JOIN 在想要在最终结果集中包含两个表中不匹配的行时非常有用。

以下查询使用`INNER JOIN`表连接到自身的查询

```sql
SELECT select_list
FROM table_name t1
INNER JOIN table_name t2 ON join_predicate;
```

此外还可以使用`LEFT JOIN`或`RIGHT JOIN`将表连接到自身：

```sql
SELECT select_list
FROM table_name t1
LEFT JOIN table_name t2 ON join_predicate;
```

## 示例

### 查询分层数据

假设有以下组织结构

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

创建`employee`表并将一些数据插入表中

```sql
CREATE TABLE employee (
	employee_id INT PRIMARY KEY,
	first_name VARCHAR (255) NOT NULL,
	last_name VARCHAR (255) NOT NULL,
	manager_id INT,
	FOREIGN KEY (manager_id)
	REFERENCES employee (employee_id)
	ON DELETE CASCADE
);
INSERT INTO employee (
	employee_id,
	first_name,
	last_name,
	manager_id
)
VALUES
	(1, 'Windy', 'Hays', NULL),
	(2, 'Ava', 'Christensen', 1),
	(3, 'Hassan', 'Conner', 1),
	(4, 'Anna', 'Reeves', 2),
	(5, 'Sau', 'Norman', 2),
	(6, 'Kelsie', 'Hays', 3),
	(7, 'Tory', 'Goff', 3),
	(8, 'Salley', 'Lester', 3);
```

使用自连接查询谁向谁报告

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
INNER JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

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

以上查询两次引用`employee`表，一次作为雇员，另一次作为经理，通过匹配`employee_id`和`manager_id`查找雇员/经理对

使用`LEFT JOIN`instead of`INNER JOIN`查询结果集中包含最高管理者

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
LEFT JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

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

### 比较同表的行

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

查询所有长度相同的电影

```sql
SELECT
    f1.title,
    f2.title,
    f1.length
FROM
    film f1
INNER JOIN film f2
    ON f1.film_id <> f2.film_id AND
       f1.length = f2.length;
```

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


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型

Postgresql - FULL OUTER JOIN


Flexbox 是一种 CSS 布局模式，用于在容器中快速、灵活地排列和对齐子元素，可以有效地实现自适应布局和响应式设计。Flexbox 的全称是 Flexible Box Layout，即“弹性盒子布局”。

Flexbox 的核心是容器和子元素之间的关系，容器称为 flex container（弹性容器），子元素称为 flex item（弹性子元素）。通过在容器上设置 display: flex 或 display: inline-flex 属性，可以将容器变为一个 flexbox，然后可以使用一系列的 CSS 属性来控制子元素的排列和对齐方式。

以下是 Flexbox 常用的属性和其作用：

- flex-direction：定义 flex container 的主轴方向，取值包括 row、row-reverse、column 和 column-reverse 四种方向。
- justify-content：定义 flex container 中子元素沿主轴方向的对齐方式，包括 flex-start、flex-end、center、space-between、space-around、space-evenly 六种取值。
- align-items：定义 flex container 中子元素沿交叉轴方向的对齐方式，包括 flex-start、flex-end、center、baseline、stretch 五种取值。
- flex-wrap：定义 flex container 中子元素在一行放不下时如何换行，取值包括 nowrap、wrap 和 wrap-reverse 三种。
- align-content：定义多行子元素在交叉轴方向的对齐方式，仅当 flex-wrap 属性为 wrap 或 wrap-reverse 时生效，包括 flex-start、flex-end、center、space-between、space-around、stretch 六种取值。
- flex-grow：定义子元素的放大比例，如果容器有多余的空间，子元素会按照各自的放大比例分配这些空间。
- flex-shrink：定义子元素的缩小比例，如果容器空间不足，子元素会按照各自的缩小比例缩小。
- flex-basis：定义子元素的基准尺寸，用于计算子元素的放大和缩小比例。
- order：定义子元素的排列顺序，数值越小的子元素越靠前。

Flexbox 的优点是可以简化布局代码，减少使用 float 和 position 的情况，同时可以实现自适应和响应式设计，提高页面的可维护性和可扩展性。但是需要注意的是，Flexbox 不适用于所有场景，例如多行文本的垂直居中需要结合其他技术实现。

以下是一个使用 Flexbox 实现的简单的响应式布局案例，包含一个 header、一个 sidebar 和一个 content 区域，可以根据屏幕尺寸自适应布局：

HTML 代码：

```html
<div class="container">
  <header>Header</header>
  <div class="content">
    <div class="sidebar">Sidebar</div>
    <div class="main">Main content</div>
  </div>
</div>
```

CSS 代码：

```css
.container {
  display: flex;
  flex-wrap: wrap;
}

header {
  width: 100%;
  background-color: #333;
  color: #fff;
  padding: 20px;
  text-align: center;
}

.content {
  display: flex;
  flex-wrap: wrap;
  flex-grow: 1;
  justify-content: flex-start;
  align-items: stretch;
}

.sidebar {
  flex-basis: 200px;
  background-color: #eee;
  padding: 20px;
}

.main {
  flex-grow: 1;
  padding: 20px;
}

@media screen and (max-width: 768px) {
  .sidebar {
    flex-basis: 100%;
  }
}
```

解释：

首先将容器设置为 flex 布局，使用 flex-wrap 属性允许子元素在需要时换行。

- header 元素使用宽度为 100%，背景颜色为深灰色，颜色为白色，使用 padding 属性来增加内边距，使其看起来更美观。

- content 元素作为 flex container，使用 flex-grow 属性让其占据剩余的空间，使用 justify-content 和 align-items 属性分别对子元素进行水平和垂直对齐。

- sidebar 元素使用 flex-basis 属性指定其基准尺寸为 200px，背景颜色为浅灰色，使用 padding 属性增加内边距。

- main 元素使用 flex-grow 属性让其占据剩余的空间，使用 padding 属性增加内边距。

- 在屏幕宽度小于 768px 时，将 sidebar 元素的基准尺寸设置为 100%，让其占据整行宽度。

这个案例展示了 Flexbox 的基本用法，通过简单的 CSS 属性设置，可以实现自适应和响应式布局。

更多请参考：[Flexbox 指南](/blog/css/tips/Flexbox指南)


css - flexbox


在 Swift 中，访问控制是一种功能，它允许开发人员限制代码的某些部分从代码的其他部分或外部代码访问。这对于保持代码的完整性和安全性以及确保它以预期方式使用非常重要。

在 Swift 中，有五个访问控制级别：

- Public：这是最高级别的访问控制。标记为 public 的代码可以从程序的任何地方访问，包括其他模块和框架。
- Open：此级别类似于 public，但具有子类外部可覆盖方法和属性的功能。
- Internal：标记为 internal 的代码可以从同一模块内的任何位置访问，但无法从模块外访问。
- File-private：此级别仅限于当前源文件。标记为 file-private 的代码仅可从同一文件中访问。
- Private：这是最严格的访问控制级别。标记为 private 的代码只能从同一声明块中访问，例如类或结构体。

使用关键字（例如“public”，“private”，“fileprivate”，“internal”和“open”）指定访问控制。如果未指定访问级别，则默认为“internal”。访问控制可以应用于代码的各个部分，包括类、方法、属性和变量。

访问控制的目的是通过限制代码的访问和修改方式来帮助防止错误和安全漏洞。例如，通过将某些变量标记为 private，开发人员可以确保只能从同一类中修改它们，减少来自代码其他部分的意外修改的风险。同样，通过将某些方法标记为 public，开发人员可以确保它们可以从程序的任何地方调用，使它们更易于其他开发人员使用。


在 Swift 中，访问控制是一种功能，它允许开发人员限制代码的某些部分从代码的其他部分或外部代码访问。

Swift - 访问控制


可选链（Optional Chaining）是 Swift 中一种用于在调用属性、方法或下标脚本时处理值可能为空的机制。

在 Swift 中，如果一个对象的属性或方法返回值类型是可选类型（Optional Type），则在访问这个属性或方法时，需要使用可选链来避免空值引用导致的运行时错误。

可选链使用问号 ? 表示，如果一个属性、方法或下标脚本可能为空，则在其名称后面加上问号 ? 表示可选链：

```swift
class Person {
    var name: String?
}

let person: Person? = Person()

// 如果 person 为 nil，则不执行 name 的赋值操作
person?.name = "Tom"
```

在上述示例中，如果 person 对象为空，即使尝试给 name 属性赋值也不会引发运行时错误。

同时，可选链也可以用于调用方法或下标脚本：

```swift
class Person {
    var name: String?

    func sayHello() {
        print("Hello, my name is \(name ?? "")")
    }

    subscript(index: Int) -> String? {
        return name
    }
}

let person: Person? = Person()

// 如果 person 为空，则不执行 sayHello 方法
person?.sayHello()

// 如果 person 为空，则返回 nil
let name = person?[0]
```

在上述示例中，使用可选链调用 sayHello 方法和获取下标脚本，即使 person 为空也不会引发运行时错误。

需要注意的是，当使用可选链调用属性或方法时，如果这个属性或方法返回的是非可选类型，那么返回的值会被自动包装为可选类型。因此，当使用可选链调用方法或属性后需要对返回的值进行解包。

```swift
class Person {
    var name: String?

    func sayHello() {
        print("Hello, my name is \(name ?? "")")
    }

    func getAge() -> Int {
        return 18
    }
}

let person: Person? = Person()

// 返回值为可选类型，需要对返回值进行解包
let age = person?.getAge()

// age 的类型为 Optional<Int>，需要对其进行解包
if let age = age {
  print(age)
}
```

在上述示例中，调用 getAge 方法返回的是一个 Int 类型，但是由于使用了可选链，返回的值被自动包装成了可选类型，需要对其进行解包。


可选链（Optional Chaining）是 Swift 中一种用于在调用属性、方法或下标脚本时处理值可能为空的机制。