安装Certbot


`React`中应用元素样式有以下几种方式：

引入全局样式

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

行内样式

```jsx
function App() {
  return (
    <header className="App-header">
      <p style={{margin: '1px', padding: '5px'}}>
        <code>src/App.js</code>
      </p>
      <a
        style={{color: 'red', backgroundColor: 'green'}}
        className="App-link"
        href="https://reactjs.org"
        target="_blank"
      >
        Learn React
      </a>
    </header>
  )
}
```

为各个组件创建单独的样式，并且在组件中使用

```jsx
import React from 'react'
import './App.css'

function App() {
  return (
    <header className="App-header">
      <p style={{margin: '1px', padding: '5px'}}>
        <code>src/App.js</code>
      </p>
      <a
        style={{color: 'red', backgroundColor: 'green'}}
        className="App-link"
        href="https://reactjs.org"
        target="_blank"
      >
        Learn React
      </a>
    </header>
  )
}

export default App
```

将 `style` 属性附加到 `JavaScript` 样式对象

```jsx
import React from 'react'

var stylingObject = {
  div: {
    color: 'red',
    border: '1px solid red'
  },
  input: {
    margin: '2px',
    padding: '5px'
  }
}

function App() {
  return (
    <div style={stylingObject.div}>
      <input style={stylingObject.input} type="text" />
    </div>
  )
}

export default App
```


React是一个JavaScript库，致力于使UI开发变得简单

React Elements Styles


**tar**用于 linux 的文件和目录创建档案，利用 tar 命令，可以把一大堆的文件和目录全部打包成一个文件

## 使用方法

```bash
tar -cf archive.tar file1 file2
#c参数代表创建压缩文档，f参数用于写入归档文件。

tar -xf archive.tar
#x参数代表解压压缩文档

tar -xf archive.tar -C directory
#C参数代表解压到某个目录

tar -tf archive.tar
#t参数代表列出压缩文档的内容
```


tar用于linux的文件和目录创建档案，利用tar命令，可以把一大堆的文件和目录全部打包成一个文件

Linux命令tar


此外，`JSX`的属性需要不同的语法。

由于`JSX`实际上是 JavaScript，JavaScript 使用 camelcase 命名约定（即“camelcase”），因此属性的编写方式与 HTML 不同。

比如，`className`和`class`是不同的，`className`是 HTML 的属性，`class`是 JavaScript 的属性。

```jsx
<div className="container"><div
```


React Elements Attributes


## 创建结构体

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

# 使用结构体
var person = Person(name: "John Appleseed", age: 42)
print(person.name) // Prints "John Appleseed"

# 更改结构体属性
person.age = 99
```

## 计算属性

`Swift`可以添加一个属性用来计算属性的值。

```swift
struct Person {
    var name: String
    var age: Int

    var ageInDogYears: Int {
        return age * 7
    }
}

let person = Person(name: "John Appleseed", age: 42)
person.ageInDogYears // Prints "294"
```

## 属性观察器

属性观察期允许在更改任何属性前后调用代码。

```swift
struct Progress {
    var task: String
    var amount: Int {
        didSet {
            print("\(task) is now \(amount)% complete")
        }
    }
}

Progress(task: "Loading data", amount: 0)

progress.amount = 30
progress.amount = 80
progress.amount = 100
```

如上代码在每次运行时都会打印出一条消息，每次设置新的值时都会打印出一条消息。

## 方法

结构体和类的方法和普通的函数完全一样。

```swift
struct Person {
    var name: String
    var age: Int

    func birthday() {
        return age + 1
    }
}

let person = Person(name: "John Appleseed", age: 42)
person.birthday() // Prints "43"
```

## 变异函数

如果结构体具有可变属性，但是结构体的实例是作为常量创建的，那么该属性不能更改。如果需要改变，应该使用`mutating`关键字。

```swift
struct Person {
    var name: String
    var age: Int

    mutating func birthday() {
        age += 1
    }
}
var person = Person(name: "John Appleseed", age: 42)
person.birthday() // Prints "43"
```

## 字符串的方法和属性

```swift
let str = "Hello, world"

str.count // Prints "12"
str.hasPrefix("Hello") // Prints "true"
str.uppercased() // Prints "HELLO, WORLD"
str.sorted() // Prints "H, E, L, L, O, , , W, , , o, r, l, d"
str.lowercased() // Prints "hello, world"
```

## 数组的方法和属性

```swift
var toys = ["Woody"]

toys.count // Prints "1"
toys.append("Buzz")
toys.firstIndex(of: "Buzz") // Prints "2"
toys.sorted() // Prints "[Buzz, Woody]"
toys.remove(at: 0)
```

## initializers

`initializers`是一种特殊的方法，它提供了不同的方法创建结构。默认情况所有结构都有一个`init`方法，它会自动调用所有的属性的`initializers`。

```swift
struct Person {
    var name: String
    var age: Int

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

var person = Person(name: "John Appleseed", age: 42)
```

## 关联当前实例

在结构方法里，使用`self`可以获取或给对应的属性赋值。类似于 js 的 this

```swift
struct Person {
    var name: String
    var age: Int

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

    func birthday() {
        self.age += 1
    }
}
```

## 惰性属性

类似于 js 的`lazyload`，仅在需要的时候创建或引入。

```swift
struct FamilyTree{
  var name:String
  lazy var familyTree = FamilyTree()

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

var ed = Person(name:"Ed")

ed.familyTree
```

## 静态属性或方法

static 变量的声明用于在结构的所有实例间共享

```swift
struct Student {
    static var classSize = 0
    var name: String

    init(name: String) {
        self.name = name
        Student.classSize += 1
    }
}

Student.classSize
```

## 访问控制

- `private` 私有属性和方法，只有在结构体内才能访问
- `public` 公共属性和方法，所有代码都可使用公共属性和方法

```swift
struct Person {
    private var id: String
    public var num: Int

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

    func identify() -> String {
        return "My social security number is \(id)"
    }
}
```

## 结构体总结

- 您可以使用结构创建自己的类型，这些结构可以有自己的属性和方法。
- 您可以使用存储的属性或使用计算的属性来动态计算值。
- 如果要更改方法内的属性，必须将其标记为`mutating`.
- 初始化器是创建结构的特殊方法。默认情况下，您会获得一个成员初始化器，但如果您创建自己的初始化器，则必须为所有属性赋值。
- 使用`self`常量来引用方法内结构的当前实例。
- `lazy`关键字告诉 `Swift` 仅在第一次使用时创建属性。
- `static`您可以使用关键字在结构的所有实例之间共享属性和方法。
- 访问控制允许您限制哪些代码可以使用属性和方法。


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

Structs - 结构体


闭包是一种自包含的函数，可以在代码中被传递和使用。闭包可以捕获和存储其所在上下文中的任何常量和变量的引用，因此被称为闭包，因为它们会封闭这些变量。Swift 中的闭包与 C 和 Objective-C 中的块（blocks）以及其他一些编程语言中的匿名函数类似。

以下是一个简单的示例，用于排序一个字符串数组：

```swift
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

func backward(_ s1: String, _ s2: String) -> Bool {
  return s1 > s2
}

var reversedNames = names.sorted(by: backward)
```

在上面的示例中，backward 函数接受两个字符串参数，比较它们的大小，并返回一个布尔值，表示第一个字符串是否在第二个字符串之后。sorted 函数接受一个闭包作为参数，并使用该闭包对数组进行排序。由于 backward 函数符合 sorted 函数要求的类型，因此可以将 backward 函数作为 sorted 函数的参数传递。

在 Swift 中，可以使用闭包表达式来定义闭包。闭包表达式使用一对花括号（{}）来定义，并且在花括号中可以指定参数列表、返回类型和函数体。

以下是使用闭包表达式进行排序的示例：

```swift
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

var reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in
  return s1 > s2
})
```

在上面的示例中，sorted 函数的参数是一个闭包表达式。闭包表达式包含了与 backward 函数相同的代码，但是这些代码被写成了更简单的形式。闭包表达式使用一对花括号来定义闭包，并指定参数列表和返回类型。在闭包体中，可以使用 return 关键字来返回值。

Swift 中的闭包还有以下特点：

- 闭包表达式可以从上下文中推断出参数类型和返回类型，因此可以省略它们。
- 闭包表达式可以使用简写参数名，用 $0、$1、$2 等来代替参数名。
- 如果闭包表达式只包含一行代码，可以省略 return 关键字。
- 可以将闭包表达式作为函数的最后一个参数传递，并将其放在圆括号外面，以提高可读性。
  以下是使用闭包表达式进行排序的更简单的示例：

```swift
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

var reversedNames = names.sorted(by: { $0 > $1 })
```

Swift 中的闭包是非常有用的工具，可以使代码更加简洁、可读和易于维护。


闭包是一种自包含的函数，可以在代码中被传递和使用

Swift - 闭包


Postgresql 允许为条件语句或表达式分配临时名称，`AS`是一个可选的选项。

## 语法

```sql
SELECT [column_name] AS [alias_name] FROM [table_name];
```

`AS`关键字是可选的

```sql
SELECT [column_name] [alias_name] FROM [table_name];
```

## 示例

使用示例数据库`customer`中的表展示如何使用别名

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

#### 分配别名

```sql
SELECT first_name,last_name FROM customer;
```

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

如果要重新命名`last_name`，可以使用`AS`关键字

```sql
SELECT first_name,last_name AS surname FROM customer;
```

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

省略`AS`关键字，则列名将被自动命名

```sql
SELECT first_name,last_name surname FROM customer;
```

#### 表达式分配别名

```sql
SELECT first_name || '' || last_name FROM customer;
```

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

可以看到表头是无意义的`?column?`，解决此问题，可以使用表达式分配别名

```sql
SELECT first_name || '' || last_name AS full_name FROM customer;
```

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

#### 包含空格的别名

如果列别名包含一个或多个空格，就需要用双引号引起来

```sql
column_name AS "column alias"
```

```sql
SELECT first_name || '' || last_name "full name" FROM customer;
```

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

## 总结

- `[column || expression] AS alias_name`为列分配别名
- `AS`关键字可选
- 如果列别名包含一个或多个空格，就需要用双引号引起来
