在 Swift 中，高级运算符是那些执行特定任务或操作的运算符。Swift 支持大部分标准 C 语言中的运算符，并增加了一些新的运算符。高级运算符可以用于自定义类型和类库中，也可以用于 Swift 标准库中定义的类型

Swift - 高级操作符


在 Swift 中，高级运算符是那些执行特定任务或操作的运算符。Swift 支持大部分标准 C 语言中的运算符，并增加了一些新的运算符。高级运算符可以用于自定义类型和类库中，也可以用于 Swift 标准库中定义的类型。Swift 中支持的高级运算符包括：

- 位运算符：按位操作二进制数据，包括按位取反、按位与、按位或、按位异或等。
- 移位运算符：用来对二进制数据进行左移或右移操作。
- 溢出运算符：对于数值类型，当其存储的值超出其所能容纳的范围时，就会发生溢出。Swift 中提供了溢出加法运算符（&+）、溢出减法运算符（&-）和溢出乘法运算符（&\*）来处理这种情况。
- 比较运算符：用于比较两个值的大小关系，包括等于、不等于、大于、小于、大于等于和小于等于等。
- 逻辑运算符：用于组合和操作布尔值，包括逻辑非、逻辑与和逻辑或。
- 匹配模式运算符：用于判断一个值是否匹配某个模式，包括元组模式、可选模式、类型转换模式等。

Swift 还提供了一些自定义高级运算符的功能。开发者可以通过运算符函数来定义新的运算符，并对其进行重载。这使得 Swift 具有更高的可读性和可维护性，并能够实现更简洁和灵活的代码实现。



协议（Protocol）是 Swift 中一种重要的类型，它描述了一种方法或者属性的集合。协议可以被任意类型实现，包括类、结构体、枚举和其他协议，从而让这些类型可以拥有相同的行为和接口。

协议定义了一些方法和属性，但不提供任何实现。实现协议的类型，必须遵循协议的要求并提供这些方法和属性的实际实现。

协议的语法如下：

```swift

protocol SomeProtocol {
// 协议定义
}
```

接下来，我们将了解协议的常见用法和特性。

## 协议的属性要求

协议可以要求实现者提供特定名字和类型的实例属性或类型属性。协议不指定属性是存储属性还是计算属性，只指定属性的名称和类型。此外，协议还要求属性是可读写的或只读的。

实现协议的类型，必须遵循协议的要求并提供这些属性的实际实现。如果协议要求实现的属性是可读写的，那么实现者必须提供一个可读写的属性实现；如果协议要求实现的属性是只读的，那么实现者可以提供一个可读的属性实现或一个只读的计算属性实现。

下面是一个协议属性要求的例子：

```swift

protocol Person {
var name: String { get set }
var age: Int { get }
}
```

这个协议定义了两个属性要求，name 和 age。name 是一个可读写的字符串类型的实例属性，age 是一个只读的整数类型的实例属性。

接下来，我们定义一个结构体 Student 来实现 Person 协议：

```swift

struct Student: Person {
var name: String
var age: Int
}
```

Student 结构体实现了 Person 协议，并提供了 name 和 age 属性的实现。由于 Person 协议要求 name 是可读写的，因此 Student 结构体提供了一个可读写的 name 属性实现。而 Person 协议要求 age 是只读的，因此 Student 结构体提供了一个只读的 age 属性实现。

## 协议的方法要求

协议可以要求实现者提供特定名字和类型的实例方法和类型方法。实现协议的类型，必须遵循协议的要求并提供这些方法的实际实现。

和属性要求一样，协议中的方法要求只定义方法名、参数以及返回类型，但不提供具体的实现。实现者必须自行实现这些方法。

下面是一个协议方法要求的例子：

当一个类型符合一个协议时，我们称这个类型为遵循该协议。协议定义了一组要求，遵循该协议的类型必须满足这些要求。

在 Swift 中，协议可以用来实现多态。这意味着，我们可以使用一个遵循该协议的实例来代替任何符合该协议的类型的实例，从而使代码更加通用。

下面是一些常见的协议和它们的使用方法：

## CustomStringConvertible

该协议可以让我们自定义类型的字符串描述。当我们打印一个遵循 CustomStringConvertible 协议的类型时，它将返回一个字符串描述。这在调试和日志记录时非常有用。

下面是一个实现 CustomStringConvertible 协议的例子：

```swift

struct Person: CustomStringConvertible {
let name: String
let age: Int

    var description: String {
        return "\(name), \(age) years old"
    }
}

let person = Person(name: "Alice", age: 28)
print(person) // Output: Alice, 28 years old
```

## Equatable

该协议可以让我们比较两个实例是否相等。当我们需要比较两个对象时，遵循 Equatable 协议的类型会自动获得 == 运算符的实现。

下面是一个实现 Equatable 协议的例子：

```swift

struct Point: Equatable {
let x: Int
let y: Int
}

let point1 = Point(x: 1, y: 2)
let point2 = Point(x: 1, y: 2)

if point1 == point2 {
print("The two points are equal.")
} else {
print("The two points are not equal.")
}
```

## Hashable

该协议可以让我们将一个类型实例转换为一个唯一的哈希值。遵循 Hashable 协议的类型可以用作字典的键或集合的元素。

下面是一个实现 Hashable 协议的例子：

```swift

struct User: Hashable {
let id: Int
let name: String
}

let user1 = User(id: 1, name: "Alice")
let user2 = User(id: 2, name: "Bob")

var userDict = [user1: "Alice", user2: "Bob"]
print(userDict[user1]) // Output: Optional("Alice")
```

## Codable

该协议可以让我们将一个类型编码为 JSON 或解码 JSON。遵循 Codable 协议的类型可以通过编码和解码操作在 Swift 和其他语言之间进行转换。

下面是一个实现 Codable 协议的例子：

```swift

struct Person: Codable {
let name: String
let age: Int
}

let person = Person(name: "Alice", age: 28)

let encoder = JSONEncoder()
let data = try encoder.encode(person)

let decoder = JSONDecoder()
let decodedPerson = try decoder.decode(Person.self, from: data)

print(decodedPerson) // Output: Person(name: "Alice", age: 28)
```


协议可以被任意类型实现，包括类、结构体、枚举和其他协议，从而让这些类型可以拥有相同的行为和接口。

Swift - 协议


## Objects

- 对象是一组插槽（键值条目）
- 公共插槽称为属性
  - 属性`key`只能是`string`或者`symbol`
- 私有插槽称为私有方法，只能通过`class`创建

![1ayzHnjKYTA2F5s](https://s2.loli.net/2022/01/08/1ayzHnjKYTA2F5s.jpg)

### 单个对象 - Single objects

```js
// 创建object
const obj = {
  name: 'John',
  age: 30,
  isAdmin: false,
  sayHi() {
    console.log('Hi')
  },
  [Symbol.toStringTag]: 'Person'
}
obj.name // John
obj.age // 30
obj.isAdmin // false
obj.sayHi() // Hi
obj.toString() // [object Object]

// 解构object
const original = {
  a: 1,
  b: {
    c: 3
  }
}
const modified = {
  ...original,
  d: 4
} // { a: 1, b: { c: 3 }, d: 4 }

// 解构合并
const DEFAULTS = {alpha: 'a', beta: 'b'}
const providedData = {alpha: 1}
const allData = {...DEFAULTS, ...providedData} // {alpha: 1, beta: 'b'}

// `Object.assign`合并对象
const target = {a: 1}

const result = Object.assign(target, {b: 2}, {c: 3, b: true}) // { a: 1, b: true, c: 3 }
```

### 原型链 - Prototype chain

原型是 `JavaScript` 的基本继承机制。甚至 `class` 也基于此。每个对象都有 `null` 或一个对象作为其原型。

```js
const obj1 = Object.create(null) // 创建一个没有原型的对象
Object.getPrototypeOf(obj1) === null // true

const proto = {
  protoProp: 'protoProp'
}
const obj2 = {
  __proto__: proto, // 将proto设置为obj2的原型
  objProp: 'objProp'
}
Object.getPrototypeOf(obj2) === proto // true
```

每个对象都继承原型的所有属性，包括不可枚举的属性。

```js
obj2.protoProp // protoProp
Reflect.ownKeys(obj2) // ['objProp', '__proto__']
```

对象的非继承属性，可以通过 `Object.getOwnPropertyDescriptor()` 获取。

### getters & setters

通过`get`和`set`方法，可以设置和获取对象的属性。

```js
const jane = {
  first: 'Jane',
  last: 'Doe',
  get full() {
    return `${this.first} ${this.last}`
  },
  set full(fullName) {
    const parts = fullName.split(' ')
    this.first = parts[0]
    this.last = parts[1]
  }
}
jane.full // Jane Doe
```


Objects


## 变量

变量是一种使用方便的占位符，用于引用计算机内存地址。

swift 每个变量指定了特定的类型，类型决定变量占用内存的大小，也决定可存储值的范围。

变量名可以由字母、数字和下划线组成，以字母或下划线开始，且区分大小写。

变量名也可以使用简单的 Unicode 字符

变量和常量可以使用 print 函数输出，在字符串中可以使用括号与反斜线插入变量

```swift
// 变量声明
var variableName = <initial value>

//实例
import Cocoa

var a = 42
print(a) //输出42

var b:float
b = 3.1415926
print(b) //输出3.1415926

var _var = "hello swift"
var 你好 = "世界"
print(_var) // hello swift
print(你好) //世界

var name = "manon"

print("\(name)") //manon
```

标准 Swift 字符串使用双引号，但不能包含换行符，如果您想要多行字符串，使用三个双引号开始和结束，如下所示：

```swift
var str1 = """
This goes
over multiple
lines
"""
print(str1) // "This goes\nover multiple\nlines"
```

如果不希望显示`\`，应该如下写：

```swift
var str2 = """
This goes \
over multiple \
lines
"""
print(str2) //"This goes nover multiple nlines"
```

## 浮点和布尔值

Swift 中的另外两种基本数据类型是双精度和布尔值。

```swift
var pi = 3.141
var awesome = true
```

## 字符串插值

> 将变量放置在字符串中

```swift
var score = 85
var str = "Your score was \(score)"

var results = "The test results are here: \(str)"
```

## 常量

> 常量一旦赋值，不能再次赋值，否则会报错。

```swift
//声明
let _const = <initial value>
let _const:Float = 3.1415926

// 命名
和变量命名相同
// 输出
和变量命名相同
```

## 类型声明

在创建变量或常量的时候可以声明数据类型，如果没有，swift 将推导其数据类型，如下：

```swift
let str = "Hello, playground" //swift推导str为String

// 主动声明类型
let album: String = "Reputation"
let year: Int = 1989
let height: Double = 1.78
let taylorRocks: Bool = true
```

## 扩展

字符串是一系列字符的集合，比如`hello world`，它的数据类型为 String

```swift
import Cocoa
//创建字符串
var str1 = "hello world"
print(str1)

//空字符串
var str2 = ""
var str3 = " manon"
if str2.isEmpty() {
	print("str2 是空字符串")
}else{
	print("str2 不是空字符串")
}

// 连接字符串

var str4 = str1 + str3
print(str4) //"hello world manon"
print('str1和str3连接：\(str4)')

// 字符串长度
print(str4.count)

// 字符串比较
if str1==str2{
	print("\(str1) 与 \(str2)是相等的")
}else{
	print("\(str1) 与 \(str2)是不相等的")
}
```

字符串函数及运算符

- `isEmpty` 判断字符串是否为空，返回布尔值
- `hasPrefix` 检查字符串是否有特定的前缀
- `hasSuffix` 检查字符串是否有特定的后缀
- `Int` 转换字符串数字为整型
- `count` 计算字符串的长度
- `utf8、utf16` 遍历 String 的 utf8 属性访问 utf8、utf16 编码
- `unicodeScalars` 遍历 String 的 unicodeScalars 属性访问 Unicode 标量编码
- `+、+=、==、<、！=` 字符串操作符


swift 提供的数据类型包括：整形 Int、浮点数 Double 和 Float、布尔类型 Bool 以及字符串类型 String、Optional、Array、Dictionary、Struct、Class 等。

Simple Types - 变量、基本数据类型、字符串插值


CSS 的 box-shadow 属性可以为元素添加一个或多个阴影效果。这个属性的值包括：

- 阴影的水平偏移量（必须指定）。
- 阴影的垂直偏移量（必须指定）。
- 阴影的模糊半径（可选）。
- 阴影的扩散半径（可选）。
- 阴影的颜色（可选）。

## 示例代码：

```css
box-shadow: 2px 2px 4px #888888;
```

这个属性指定了一个偏移量为 2px 的水平阴影，一个偏移量为 2px 的垂直阴影，一个模糊半径为 4px 的阴影，阴影的颜色为 #888888。

如果要为元素添加多个阴影，可以使用逗号分隔它们。示例代码：

```css
box-shadow: 2px 2px 4px #888888, -2px -2px 4px #333333;
```

这个属性指定了两个阴影，一个是偏移量为 2px 的水平阴影和偏移量为 2px 的垂直阴影，模糊半径为 4px，颜色为 #888888，另一个阴影是偏移量为 -2px 的水平阴影和偏移量为 -2px 的垂直阴影，模糊半径为 4px，颜色为 #333333。

还可以使用 inset 关键字指定内阴影，示例代码：

```css
box-shadow: inset 2px 2px 4px #888888;
```

这个属性指定了一个偏移量为 2px 的水平内阴影和偏移量为 2px 的垂直内阴影，模糊半径为 4px，颜色为 #888888。

除了 box-shadow，CSS 还有 text-shadow 属性，它可以为文本添加阴影效果。text-shadow 的用法和 box-shadow 很相似，只是它只能为文本添加阴影，而不能为元素添加阴影。

使用 box-shadow 属性的简单案例，实现了一个卡片效果：

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

HTML 代码：

```html
<div class="card">
  <h2>Card Title</h2>
  <p>Card Content</p>
</div>
```

CSS 代码：

```css
.card {
  width: 300px;
  height: 200px;
  background-color: #ffffff;
  border-radius: 10px;
  box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.1);
}

.card h2 {
  margin-top: 20px;
  text-align: center;
}

.card p {
  margin-top: 40px;
  text-align: center;
}
```

解释：

这个案例中，我们首先创建了一个 div 元素，并给它添加了一个类名为 "card"。然后，我们为这个 div 元素设置了宽度和高度，背景色和圆角属性。接着，我们使用 box-shadow 属性为这个 div 元素添加了一个阴影效果，它的偏移量为 0px 的水平阴影和偏移量为 4px 的垂直阴影，模糊半径为 10px，颜色为 rgba(0, 0, 0, 0.1)。


css - shadows


在 Next.js 中，可以创建动态路由。比如：

- `[id].js`，表示 id 为相对路径的动态页面
- `lib/posts.js`，表示在 lib 目录下的 post 页面

创建`[id].js`

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

import {getAllPostIds, getPostData} from '../../lib/posts'

export default function Post({postData}) {
  return (
    <Container>
      {postData.id}
      <br />
      {postData.title}
      <br />
      {postData.date}
    </Container>
  )
}
export async function getStaticPaths() {
  const paths = getAllPostIds()
  return {
    paths,
    fallback: false
  }
}

export async function getStaticProps({params}) {
  const postData = getPostData(params.id)
  return {
    props: {
      postData
    }
  }
}
```

创建`lib/posts.js`

```jsx
export function getPostData(id) {
  const postOne = {
    title: 'One',
    id: 1,
    date: '7/12/2020'
  }

  const postTwo = {
    title: 'Two',
    id: 2,
    date: '7/12/2020'
  }
  if (id == 'one') {
    return postOne
  } else if (id == 'two') {
    return postTwo
  }
}

export function getAllPostIds() {
  return [
    {
      params: {
        id: 'one'
      }
    },
    {
      params: {
        id: 'two'
      }
    }
  ]
}
```

启动服务

```bash
npm run dev
```

验证结果

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


在 Next.js 中，可以创建动态路由