File System是一个文件系统模块，用于操作文件系统。

Node.js - File System


## 字符串文本

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

```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 - 字符类型


## API 中间件

`Next.js`提供了内置的路由中间件用于解析入参等。

- `req.cookies`：获取客户端的 cookie
- `req.query`：获取客户端的 query
- `req.body`：获取客户端的 body

```jsx
export default (req, res) => {
  res.statusCode = 200
  res.setHeader('Content-Type', 'application/json')
  res.end(JSON.stringify({query: req.query}))
}
```

## 配置跨域

你还可以使用 Connect 兼容的中间件，比如使用 `cors`：

```jsx
import Cors from 'cors'

// Initializing the cors middleware
const cors = Cors({
  methods: ['GET', 'HEAD']
})

// Helper method to wait for a middleware to execute before continuing
// And to throw an error when an error happens in a middleware
function runMiddleware(req, res, fn) {
  return new Promise((resolve, reject) => {
    fn(req, res, (result) => {
      if (result instanceof Error) {
        return reject(result)
      }

      return resolve(result)
    })
  })
}

async function handler(req, res) {
  // Run the middleware
  await runMiddleware(req, res, cors)

  // Rest of the API logic
  res.json({message: 'Hello Everyone!'})
}

export default handler
```


Next.js - API MiddleWares


内存安全是编程语言中的一个重要概念，它指的是在程序执行过程中，确保所有内存访问都是合法的、有效的，不会导致内存泄漏、访问未初始化的内存或非法访问其他应用程序的内存等问题。Swift 是一种内存安全的语言，它通过一系列的机制来确保内存访问的安全性。

Swift 中的内存安全机制主要包括以下几个方面：

- ARC（Automatic Reference Counting，自动引用计数）：ARC 是一种自动内存管理机制，它通过对对象引用计数的跟踪来管理内存。当一个对象没有任何引用时，ARC 会自动释放这个对象所占用的内存。
- 可选类型：Swift 中的可选类型可以表示一个值存在或者不存在的状态，它可以避免空指针异常等问题。在 Swift 中，如果一个可选类型没有明确赋值，那么它的值默认为 nil。
- 访问控制：Swift 提供了访问控制机制，可以限制对某些代码的访问权限，从而防止未经授权的访问。
- 内存访问检查：Swift 对数组、字典、字符串等常用类型的访问进行了检查，避免了越界访问等问题。
- copy-on-write 语义：Swift 中的某些类型，比如数组和字典，采用了 copy-on-write 语义。当这些类型的值被复制时，实际上并不会立即进行复制，而是共享同一块内存空间。只有在其中一个值被修改时，才会进行实际的复制操作，从而避免了不必要的内存开销。

通过以上这些机制，Swift 可以保证程序在运行过程中不会出现内存泄漏、空指针异常等问题，从而提高了程序的可靠性和稳定性。


内存安全是编程语言中的一个重要概念，它指的是在程序执行过程中，确保所有内存访问都是合法的、有效的，不会导致内存泄漏、访问未初始化的内存或非法访问其他应用程序的内存等问题。Swift 是一种内存安全的语言，它通过一系列的机制来确保内存访问的安全性。

Swift - 内存安全


在 Swift 中，类型转换(Type Casting)指的是检查一个实例的类型，或将该实例视为其超类或子类之一的过程。

Swift 提供了两种类型转换方式：

- 通过类型检查来检查实例的类型是否与特定的类型相同（或是子类或父类）：使用 is 和 as 操作符来完成类型检查。

  - is 操作符用于检查一个实例是否属于某个特定类型或其子类。返回值为布尔类型。
  - as? 操作符用于尝试将实例转换为特定类型。如果转换成功，返回一个可选类型的实例，否则返回 nil。
  - as! 操作符强制将实例转换为特定类型。如果转换失败，会抛出一个运行时错误。

- 通过向下转换来将父类实例转换为其子类实例：使用 as? 或 as! 操作符完成向下转换。
  - as? 操作符尝试将父类实例转换为子类实例。如果转换成功，返回一个可选类型的子类实例，否则返回 nil。
  - as! 操作符强制将父类实例转换为子类实例。如果转换失败，会抛出一个运行时错误。

下面是一个示例代码：

```swift
class Animal {
  func makeSound() {
    print("I am an animal")
  }
}

class Dog: Animal {
  override func makeSound() {
    print("Woof!")
  }
}

let animal = Animal()
let dog = Dog()

// Type check
if dog is Animal {
  print("dog is an Animal")
}

// Downcasting
let maybeDog = animal as? Dog
if let dog = maybeDog {
  dog.makeSound()
} else {
  print("Not a dog")
}

// Forced downcasting
let definitelyDog = animal as! Dog // Runtime error!
```

在上面的代码中，我们创建了一个 Animal 类和一个继承自 Animal 的 Dog 类。使用 is 操作符检查 dog 实例是否是 Animal 类的子类，并使用 as? 操作符尝试将 Animal 实例转换为 Dog 实例。最后，使用 as! 操作符强制将 Animal 实例转换为 Dog 实例（如果尝试转换一个非 Dog 实例，则会引发运行时错误）


在Swift中，类型转换(Type Casting)指的是检查一个实例的类型，或将该实例视为其超类或子类之一的过程。。

Swift - 类型转换


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

1. 安装`fontawesome`

```bash
npm install @fortawesome/fontawesome-svg-core @fortawesome/free-solid-svg-icons @fortawesome/react-fontawesome
```

2. 编辑`_app.js`

```js
import '@fortawesome/fontawesome-svg-core/styles.css' // import Font Awesome CSS
import {config} from '@fortawesome/fontawesome-svg-core'
config.autoAddCss = false // Tell Font Awesome to skip adding the CSS automatically since it's being imported above

const App = ({Component, pageProps}) => {
  return <Component {...pageProps} />
}

export default App
```

3. 在组件中使用`FontAwesomeIcon`

```js
// index.js

// Import the FontAwesomeIcon component
import {FontAwesomeIcon} from '@fortawesome/react-fontawesome'

// import the icons you need
import {
  faSearch,
  faAmbulance,
  faAnchor
} from '@fortawesome/free-solid-svg-icons'

const Home = (props) => {
  return (
    <div>
      <FontAwesomeIcon icon={faSearch} style={{fontSize: 100, color: 'blue'}} />

      <FontAwesomeIcon
        icon={faAmbulance}
        style={{fontSize: 100, color: 'orange'}}
      />

      <FontAwesomeIcon
        icon={faAnchor}
        style={{fontSize: 100, color: 'green'}}
      />
    </div>
  )
}

export default Home
```

4. 效果

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


Next.js是基于React的框架，具有服务器端渲染功能。

Next.js - Use Font Awesome with Next.js


Next.js 内置了 Typescript 支持。

首先，在项目根目录新建`tsconfig.json`，Next.js 会自动检测项目中的`tsconfig.json`文件，并将其解析为项目的配置。

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

接下来安装相关依赖

```bash
npm install -D typescript @types/react @types/node
```

启动服务

```bash
npm run dev
```

打开`tsconfig.json`，可以看到内容已经被`Next.js`修改

```json
{
  "compilerOptions": {
    "target": "es5",
    "lib": ["dom", "dom.iterable", "esnext"],
    "allowJs": true,
    "skipLibCheck": true,
    "strict": false,
    "forceConsistentCasingInFileNames": true,
    "noEmit": true,
    "incremental": true,
    "esModuleInterop": true,
    "module": "esnext",
    "moduleResolution": "node",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "jsx": "preserve"
  },
  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
  "exclude": ["node_modules"]
}
```

创建`hello.ts`

```tsx
import {NextApiRequest, NextApiResponse} from 'next'
export default (req: NextApiRequest, res: NextApiResponse) => {
  res.status(200).json({
    message: 'Hello World'
  })
}
```
