ARC 的作用是在程序运行时自动管理对象的内存，从而避免了手动管理内存的繁琐和容易出错的问题。

Swift - ARC(内存管理机制)


## 字符串文本

> 字符串文本通常是由单引号或者双引号括起来的。通常单行单引号，多行三引号。

```python
# Single quote
a = 'Yeah but no but yeah but...'

# Double quote
b = "computer says no"

# Triple quotes
c = '''
Look into my eyes, look into my eyes, the eyes, the eyes, the eyes,
not around the eyes,
don't look around the eyes,
look into my eyes, you're under.
'''
```

## 字符串转义

```python
'\n'      # 换行
'\r'      # 回车
'\t'      # 水平制表符
'\''      # 单引号
'\"'      # 双引号
'\\'      # 反斜杠
```

## 字符串运算

```python
+  # 字符串连接
*  # 重复
[] # 取子串
[:] # 截取字符串的一部分
in # 判断字符串是否包含某个字符串
not in # 判断字符串是否不包含某个字符串
r/re # 匹配字符串
% # 格式化字符串


a = "Hello"
b = "Python"

print "a + b 输出结果：", a + b
print "a * 2 输出结果：", a * 2
print "a[1] 输出结果：", a[1]
print "a[1:4] 输出结果：", a[1:4]

if( "H" in a) :
    print "H 在变量 a 中"
else :
    print "H 不在变量 a 中"

if( "M" not in a) :
    print "M 不在变量 a 中"
else :
    print "M 在变量 a 中"

print r'\n'
print R'\n'
```

## 字符串方法

```python
s = ' Hello'
t = s.strip() #'Hello'去除空格
l = s.lower() #' hello' 全部转换为小写
u = s.upper() #' HELLO' 全部转换为大写
c = s.capitalize() #'Hello' 字符串首字母大写
t = s.replace('H', 'J') #'Jello' 将所有的H替换为J

s.endswith(suffix)     # 判断字符串是否以指定后缀结尾
s.find(t)              # 查找字符串中指定字符或字符串的索引位置
s.index(t)             # 查找字符串中指定字符或字符串的索引位置
s.isalpha()            # 判断字符串是否只有字母
s.isdigit()            # 判断字符串是否只有数字
s.islower()            # 判断字符串是否只有小写
s.isupper()            # 判断字符串是否只有大写
s.join(slist)          # 将字符串s与字符串列表slist中的字符串连接
s.lower()              # 转换字符串中所有大写字符为小写
s.replace(old,new)     # 替换字符串中的指定字符串
s.rfind(t)             # 从右边开始查找字符串中指定字符或字符串的索引位置
s.rindex(t)            # 从右边开始查找字符串中指定字符或字符串的索引位置
s.split([delim])       # 将字符串分割成一个列表
s.startswith(prefix)   # 判断字符串是否以指定前缀开头
s.strip()              # 去掉字符串左右两边的空格
s.upper()              # 转换字符串中的小写字母为大写
```

## 字符串类型转换

> 使用`str()`将任何值转换成字符串

```python
x=42
str(x) #'42'
```

## 其他字符类型

```python
# 字节类型
data = b'Hello World\r\n'
len(data)                         # 13
data[0:5]                         # b'Hello'
data.replace(b'Hello', b'Cruel')  # b'Cruel World\r\n'

# Raw字节类型
>>> rs = r'c:\newdata\test' # Raw (uninterpreted backslash)
>>> rs
'c:\\newdata\\test'

# f-string
>>> name = 'IBM'
>>> shares = 100
>>> price = 91.1
>>> a = f'{name:>10s} {shares:10d} {price:10.2f}'
>>> a
'       IBM        100      91.10'
>>> b = f'Cost = ${shares*price:0.2f}'
>>> b
'Cost = $9110.00'
>>>
```


Strings - 字符类型


LIMIT 语句经常在许多关系型数据库中使用，比如 MySQL，H2，HSQLDB。

但是 LIMIT 语句不属于 SQL 标准。

Postgresql 提供了 SQL 标准的语句来替代 LIMIT，它就是 FETCH 语句，它是在 SQL：2008 标准被提出来的。

## 语法

```sql
OFFSET start { ROW | ROWS }
FETCH { FIRST | NEXT } [ row_count ] { ROW | ROWS } ONLY
```

FIRST 和 NEXT 是同义词，ROW 和 ROWS 是同义词，同义词可以相互替换

start 必须为 0 或正整数，如果没有 OFFSET 字句，则 start 默认为 0，如果 start 比结果集中的行数大，则查询语句不返回结果。

row_count 是大于等于 1 的整数，如果你不指定它，它默认为 1

因为表中存储的行顺序是未指定的，所以应该始终使用 FETCH 子句和 order BY 子句，以使返回结果集中的行顺序一致。

## FETCH vs LIMIT

使用 FETCH 查询并选择第一条记录

```sql
SELECT
    film_id,
    title
FROM
    film
ORDER BY
    title
FETCH FIRST ROW ONLY;
```

![bQ3nfm](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/bQ3nfm.jpg)
等同于以下代码：

```sql
SELECT
    film_id,
    title
FROM
    film
ORDER BY
    title
FETCH FIRST 1 ROW ONLY;
```

## 总结

尽量使用 FETCH 语句，而不是 LIMIT 语句。


如何使用 PostgreSQL FETCH 检索查询返回的部分行

Postgresql - FETCH


Performance API 是一个浏览器提供的 API，可用于测量和分析 Web 应用程序的性能。下面是使用 Performance API 的一般步骤：

- 获取 Performance 对象：使用 window.performance 属性可以获取 Performance 对象。
- 使用 Performance.timing 属性获取时间信息：Performance.timing 属性返回一个对象，其中包含了各种时间信息，例如页面加载时间、DNS 解析时间等等。
- 使用 Performance.navigation 属性获取导航信息：Performance.navigation 属性返回一个对象，其中包含了导航信息，例如重定向次数等等。
- 使用 Performance.mark()方法进行标记：Performance.mark()方法可用于在代码中标记关键点，例如页面开始加载和结束加载。这样可以方便地跟踪代码执行的性能。
- 使用 Performance.measure()方法进行测量：Performance.measure()方法可用于测量两个标记之间的时间差，例如页面加载时间。
- 使用 Performance.getEntries()方法获取性能条目：Performance.getEntries()方法返回一个包含所有性能条目的数组，可以使用它来获取更详细的性能数据。

下面是一个简单的示例，演示如何使用 Performance API 测量页面加载时间：

```javascript
// 获取Performance对象
const performance = window.performance

// 在代码中标记关键点
performance.mark('start')

// 当页面加载完成后，再次标记关键点
window.addEventListener('load', () => {
  performance.mark('end')

  // 测量页面加载时间
  performance.measure('loadTime', 'start', 'end')

  // 获取性能条目
  const entries = performance.getEntries()

  // 打印页面加载时间
  console.log('页面加载时间:', entries[0].duration)
})
```

> Performance API 的可用性和功能因浏览器而异，因此在使用它时需要进行兼容性测试

除了上述基本的使用方法外，Performance API 还提供了一些其他的功能，例如：

- Performance.now()方法：Performance.now()方法返回从页面加载开始到当前时间的毫秒数，可用于测量代码执行时间。
- Performance.memory 属性：Performance.memory 属性返回一个对象，其中包含了内存使用情况的信息，例如当前内存使用量和总内存使用量。
- PerformanceObserver 接口：PerformanceObserver 接口可用于监视 Performance API 中的事件和条目，例如资源加载事件和用户交互事件。

下面是一个简单的示例，演示如何使用 PerformanceObserver 接口监视页面中的资源加载事件：

```javascript
// 获取Performance对象
const performance = window.performance

// 创建PerformanceObserver对象
const observer = new PerformanceObserver((list) => {
  // 获取所有资源加载事件的条目
  const entries = list
    .getEntries()
    .filter((entry) => entry.entryType === 'resource')

  // 打印每个资源的加载时间
  entries.forEach((entry) => {
    console.log(`${entry.name}的加载时间为${entry.duration}毫秒`)
  })
})

// 开始监视资源加载事件
observer.observe({type: 'resource', buffered: true})
```

在这个示例中，我们使用 PerformanceObserver 接口创建了一个观察器，监视所有资源加载事件的条目，并打印每个资源的加载时间。请注意，要监视 Performance API 中的事件和条目，需要使用 PerformanceObserver 接口。

除了前面提到的功能之外，Performance API 还提供了一些高级功能，例如：

- Navigation Timing Level 2：Navigation Timing Level 2 是 Performance API 的一个扩展，提供了更详细的导航信息和时间信息。例如，它可以提供更准确的页面加载时间、页面卸载时间和重定向时间等信息。
- Long Tasks API：Long Tasks API 可用于测量页面上执行时间较长的任务，例如 JavaScript 代码或布局计算。这可以帮助开发人员识别和优化慢速操作。
- Paint Timing API：Paint Timing API 可用于测量页面上的绘制时间，例如首次绘制时间和重绘时间。这可以帮助开发人员识别和优化页面绘制问题。
- User Timing API：User Timing API 可用于在代码中创建自定义的时间标记和测量，例如代码块的执行时间和用户交互时间。这可以帮助开发人员更精细地测量代码执行性能。

下面是一个简单的示例，演示如何使用 User Timing API 测量代码块的执行时间：

```javascript
// 获取Performance对象
const performance = window.performance

// 在代码中标记关键点
performance.mark('start')

// 执行一个耗时的代码块
for (let i = 0; i < 1000000000; i++) {}

// 再次标记关键点
performance.mark('end')

// 测量代码块的执行时间
performance.measure('代码块执行时间', 'start', 'end')

// 获取性能条目
const entries = performance.getEntries()

// 打印代码块的执行时间
console.log('代码块执行时间:', entries[0].duration)
```

在这个示例中，我们使用 User Timing API 在代码中标记了关键点，并测量了执行时间。请注意，User Timing API 可以在代码中创建自定义的时间标记和测量，从而更精细地测量代码执行性能。

总的来说，Performance API 提供了很多有用的功能，可以帮助开发人员识别和解决 Web 应用程序中的性能问题。开发人员可以根据应用程序的需求选择适合的 API 和方法，从而优化 Web 应用程序的性能。


Performance API是一个浏览器提供的API，可用于测量和分析Web应用程序的性能

Performance API


## 添加和使用资源

在Flutter中，资源可以包括静态数据，如图像、字体和JSON文件，这些数据需要与应用程序一起打包，以使其正确运行。要将资源添加到Flutter项目中，您需要在项目的根目录下的pubspec.yaml文件中指定它们。

以下是如何添加图像的步骤：

1. 在项目的根目录下创建一个名为assets的目录。
1. 将图像放置在该目录中。
1. 在pubspec.yaml中添加以下内容：

```yaml
flutter:
  assets:
    - assets/my_image.png
```

现在，您可以在代码中使用该图像，例如：

```yaml
Image.asset('assets/my_image.png')
```

类似地，您可以添加其他类型的资源并在项目中使用它们。

## 在Flutter中设置导航

导航是任何应用程序的关键部分。在Flutter中，您可以使用Navigator类在不同的屏幕之间进行导航。Navigator的工作原理类似于堆栈，您可以在其上推入新的路由（屏幕），也可以弹出路由。

以下是如何导航到新屏幕的简单示例：

```dart
Navigator.push(context, MaterialPageRoute(builder: (context) => SecondScreen()));
```

在上面的代码中，SecondScreen是一个新的小部件，当用户导航到该路由时，它将显示在屏幕上。

您还可以使用命名路由进行导航。首先，您需要在主应用程序小部件中定义路由：

```dart
MaterialApp(
  initialRoute: '/',
  routes: {
    '/': (context) => FirstScreen(),
    '/second': (context) => SecondScreen(),
  },
);
```

然后，您可以通过以下方式导航到第二个屏幕：

```dart
Navigator.pushNamed(context, '/second');
```

总之，一旦您理解了基本概念，使用资源和导航在Flutter中非常简单。随着您继续构建更复杂的应用程序，这些概念将变得非常熟悉。


Working with Assets and Navigation in Flutter


Docker 中的网络是像容器和镜像一样的另一个逻辑对象。就像其他两个一样，在 docker network 组下有大量的命令可以操纵网络。

要列出系统中的网络，请执行以下命令：

```bash
docker network ls

# NETWORK ID     NAME      DRIVER    SCOPE
# c2e59f2b96bd   bridge    bridge    local
# 124dccee067f   host      host      local
# 506e3822bf1f   none      null      local
```

在表格中查看 DRIVER 列。这些驱动程序可以被视为网络类型。

默认情况下，Docker 有五种网络驱动程序，如下：

- bridge：Docker 中的默认网络驱动程序。当多个容器以标准模式运行并需要相互通信时，可以使用此驱动程序。
- host：完全删除网络隔离。在主机网络下运行的任何容器本质上都附加到主机系统的网络。
- none：此驱动程序完全禁用容器的网络。我还没有发现任何使用场景。
- overlay：用于连接多个 Docker 守护进程的工具，超出了本书的范围。
- macvlan：允许分配 MAC 地址给容器，使它们在网络中像物理设备一样工作。

还有第三方插件，允许您将 Docker 与专用网络堆栈集成。在上面提到的五个中，只需使用桥接网络驱动程序。
