Next.js - Routing


Python 有三种序列类型：列表、元组、字符串。

- String：`'123'`
- List：`[1, 2, 3]`
- Tuple：`(1, 2, 3)`

所有序列都是有序的，可以通过索引来访问元素，索引从 0 开始。

```python
a = 'Hello'               # String
b = [1, 4, 5]             # List
c = ('GOOG', 100, 490.1)  # Tuple

# Indexed order
a[0]                      # 'H'
b[-1]                     # 5
c[1]                      # 100

# Length of sequence
len(a)                    # 5
len(b)                    # 3
len(c)                    # 3
```

序列可以复制`repeat`

```python
>>> a = 'Hello'
>>> a * 3
'HelloHelloHello'
>>> b = [1, 2, 3]
>>> b * 2
[1, 2, 3, 1, 2, 3]
>>>
```

相同类型的序列可以相加

```python
>>> a = (1, 2, 3)
>>> b = (4, 5)
>>> a + b
(1, 2, 3, 4, 5)
>>>
>>> c = [1, 5]
>>> a + c
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate tuple (not "list") to tuple
```

## 切割

切割的意思是把序列分成多个部分，`s[start:end]`，比如：

```python
a = [0,1,2,3,4,5,6,7,8]

a[2:5]    # [2,3,4]
a[-5:]    # [4,5,6,7,8]
a[:3]     # [0,1,2]
```

> `start` 和 `end` 可以是负数，但必须为整数，表示从右往左的索引。
> 如果 `start` 比 `end` 大，则返回空序列。
> 如果 `start` 和 `end` 相等，则返回一个元素。
> 如果 `start` 比 `end` 都为空，则返回整个序列。

## 切割后重新定义

列表的切片可以重新定义，比如：

```python
a = [0,1,2,3,4,5,6,7,8]
a[2:4] = [10,11,12] # [0,1,10,11,12,5,6,7,8]
```

列表的切片也可以被删除，比如：

```python
a = [0,1,2,3,4,5,6,7,8]
del a[2:4] # [0,1,5,6,7,8]
```

## 序列升序执行（reduce）

```python
s = [1, 2, 3, 4, 5]
sum(s) # 15
min(s) # 1
max(s) # 5
t = ['hello', 'world']
max(t) # 'world'
```

## 序列的迭代

```python
s = [1, 4, 9, 16]
for i in s:
  print(i)

1
4
9
16
```

### break、continue 语句

```python
for name in namelist:
    if name == 'Jake':
        break
    ...
    ...
statements

for line in lines:
    if line == '\n':    # Skip blank lines
        continue
    # More statements
    ...
```

### for and tuples

可以使用多个迭代变量进行迭代。

```python
points = [
  (1, 4),(10, 40),(23, 14),(5, 6),(7, 8)
]
for x, y in points:
    # Loops with x = 1, y = 4
    #            x = 10, y = 40
    #            x = 23, y = 14
    #            ...
```

## zip

`zip` 函数可以将多个序列合并为一个序列，比如：

```python
columns = ['name', 'shares', 'price']
values = ['ACME', 100, 490.1]
pairs = zip(columns, values)
# pairs = [('name', 'ACME'), ('shares', 100), ('price', 490.1)]
```


Python 有三种序列类型：列表、元组、字符串。

Sequences - 序列


在 ECMAScript 中，变量可以存在两种类型的值，即原始值和引用值。

1. 原始值占用的内存空间是固定的，而引用值占用的内存空间是动态的。
2. 原始值的值存储在栈中，而引用值的值存储在堆中。
3. 原始值的保存与复制是直接的，而引用值的保存与复制是通过值的拷贝来实现的。
4. 原始值使用`typeof`运算符来检测其类型，而引用值使用`instanceof`运算符来检测其类型。
5. 原始值的值可以通过`==`运算符来比较，而引用值的值可以通过`===`运算符来比较。
6. 使用`new()`构造出的对象是引用值，而不是原始值。

> 除了`null`和`undefined`之外，所有的基本类型都是原始值，而所有的引用类型都是引用值。

## 基本类型

- number
- boolean
- bigint
- string
- symbol
- null
- undefined

## 引用类型

- object
- array
- function

```js
const number = 10

const bool = false

const str = 'Hello!'

const missingObject = null

const nothing = undefined
```

基本类型的值是存储在栈中的，所以在 JavaScript 中，基本类型的值可替换但不可被改变。

```js
var bar = 'baz'
console.log(bar) // baz
bar.toUpperCase()
console.log(bar) // baz

// 使用数组方法可以改变一个数组
var foo = []
console.log(foo) // []
foo.push('plugh')
console.log(foo) // ["plugh"]

// 赋值行为可以给基本类型一个新值，而不是改变它
bar = bar.toUpperCase() // BAZ
```

```js
// 基本类型
let foo = 5

// 定义一个貌似可以改变基本类型值的函数
function addTwo(num) {
  num += 2
}
// 和前面的函数一样
function addTwo_v2(foo) {
  foo += 2
}

// 调用第一个函数，并传入基本类型值作为参数
addTwo(foo)
// Getting the current Primitive value
console.log(foo) // 5

// 尝试调用第二个函数...
addTwo_v2(foo)
console.log(foo) // 5
```

**在执行函数体内语句之前，JavaScript 会将传递进来的参数（基本类型的值）复制一份，创建一个本地副本。这个副本只存在于该函数的作用域中，我们能够通过指定在函数中的标识符访问到它（addTwo 中的 num，addTwo_v2 中的 foo）。**


基本类型与引用类型


在 JavaScript 中，undefined 是一个原始值，表示没有值。它是未初始化变量的默认值，也是没有返回值的函数返回的值。

你可以使用 undefined 值来检查变量是否已初始化或函数是否已返回值：

```js
let x
console.log(x === undefined) // true

function f() {}
console.log(f() === undefined) // true
```

请注意，undefined 与 null 不同，null 表示没有对象值。在 JavaScript 中，null 是可以赋值给变量的值，而 undefined 是未初始化变量的默认值。

你还可以使用 typeof 运算符来检查一个值是否为 undefined。typeof 运算符对于 undefined 值会返回字符串 "undefined"：

```js
console.log(typeof undefined) // "undefined"
```

此外，你还可以使用 undefined 值将变量重置为其默认值：

```js
let x = 1
x = undefined // x 现在为 undefined
```

通常认为使用 undefined 值重置变量是不好的做法，因为它会导致混淆，使代码难以理解。相反，最好是明确将变量设置为 null 或其他在代码上下文中有意义的值。

总之，undefined 是 JavaScript 中的原始值，表示没有值。它是未初始化变量的默认值，也是没有返回值的函数返回的值。您可以使用“未定义”值来检查变量是否已初始化，或者函数是否已返回值，您还可以使用`typeof`操作符来检查值是否为 undefined。然而，使用 typeof 来检查值是否为 undefined 来重置变量通常被认为是一种不好的做法。


Undefined


## 字符串的定义：

Swift 中可以使用两种方式来定义字符串：

- 使用双引号("")将字符串括起来。
- 使用三个双引号(""")来定义多行字符串。
  例如：

```swift
let str1 = "Hello, world!" // 使用双引号定义字符串
let str2 = """
This is a
multi-line
string.
""" // 使用三个双引号定义多行字符串
```

Swift 中的字符类型（Character）表示一个单独的字符，通常用于表示一个字母、数字、符号或空格等单个文本字符。

## 字符的定义：

Swift 中使用单引号('')来定义字符，例如：

```swift
let char1: Character = "A" // 定义单个字符
```

在字符串中，可以使用字符的集合来表示一段文本。例如：

```swift
let str3 = "Swift"
for char in str3 {
print(char)
}
```

上述代码会输出字符串 "Swift" 中的每个字符，即 "S"、"w"、"i"、"f"、"t"。

Swift 中的字符串和字符类型还支持各种文本处理功能，例如拼接、截取、查找、替换、转换大小写等。这些功能可通过使用字符串和字符类型的内置方法和属性来实现。

以下是一些常见的字符串和字符处理方法和属性的示例：

## 字符串拼接

可以使用加号运算符（+）将两个字符串连接起来。例如：

```swift
let str1 = "Hello"
let str2 = "world"
let str3 = str1 + " " + str2 // "Hello world"
```

## 字符串截取

可以使用下标操作符([])和 range(范围)操作符(...和..\<)从字符串中截取一段子字符串。例如：

```swift
let str = "Hello, world!"
let subStr1 = str[..<5] // "Hello"
let subStr2 = str[7...] // "world!"
let subStr3 = str[7..<12] // "world"
```

## 字符串查找

可以使用内置的 contains() 方法查找字符串是否包含某个子字符串，也可以使用 range(of: String) 方法查找子字符串的范围。例如：

```swift
let str = "Hello, world!"
let hasWorld = str.contains("world") // true
let range = str.range(of: "world") // Range<String.Index>(7..<12)
```

## 字符串替换

可以使用 replaceSubrange() 方法替换字符串中的一段子字符串。例如：

```swift
var str = "Hello, world!"
str.replaceSubrange(7..<12, with: "Swift") // "Hello, Swift!"
```

## 字符串大小写转换

可以使用 uppercased() 方法将字符串中的所有字符转换为大写，使用 lowercased() 方法将其转换为小写。例如：

```swift
let str = "Hello, world!"
let upperStr = str.uppercased() // "HELLO, WORLD!"
let lowerStr = str.lowercased() // "hello, world!"
```

## 字符串和数字类型的相互转换

可以使用 String() 方法将数字类型转换为字符串，使用 Int()、Float() 或 Double() 等方法将字符串转换为相应的数字类型。例如：

```swift
let num = 123
let str = String(num) // "123"

let str2 = "3.14"
let floatNum = Float(str2) // 3.14
```


字符串（String）是一种用于存储和操作文本的类型。字符串由一系列字符（Character）组成，可以包含字母、数字、符号和空格等文本字符。Swift 的字符串类型是可变的（Mutable），可以修改其值。

Swift - 字符、字符串


`crypto`模块提供了加密功能，其中包括了用于 OpenSSL 散列、HMAC、加密、解密、签名、以及验证的函数的一整套封装。

几种常见的加密、解密算法：

- hash HMAC
- cipher
- decipher
- sign
- verify

## 什么是 hash

hash 是一种散列函数，用于生成一个唯一的值，用于比较两个值是否相同。

## 什么是 HMAC

HMAC 是一种基于 hash 的密钥的认证算法，它可以用于验证数据的完整性，以及防止被篡改。

```js
const {createHmac} = require('crypto')

const secret = 'abcdefg'
const hash = createHmac('sha256', secret)
  .update('I love cupcakes')
  .digest('hex')
console.log(hash)
// c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
```

使用`cipher`加密

```js
const crypto = require('crypto')
const cipher = crypto.createCipher('aes192', 'a password')

var encrypted = cipher.update('some clear text data', 'utf8', 'hex')
encrypted += cipher.final('hex')

console.log(encrypted)
```

使用`decipher`解密

```js
const crypto = require('crypto')
const decipher = crypto.createDecipher('aes192', 'a password')

var encrypted =
  'c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e'
var decrypted = decipher.update(encrypted, 'hex', 'utf8')
decrypted += decipher.final('utf8')
console.log(decipher)
```

使用`sign`签名

```js
const crypto = require('crypto')
const buffer = require('buffer')

const {privateKey, publicKey} = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048
})

const data = Buffer.from('I Love GeeksForGeeks')

const sign = crypto.sign('SHA256', data, privateKey)

const signature = sign.toString('base64')

console.log(`Signature:\n\n ${signature}`)
```

使用`verify`验证

```js
const crypto = require('crypto')
const buffer = require('buffer')

const {privateKey, publicKey} = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048
})
const algorithm = 'SHA256'

const data = Buffer.from('I Love GeeksForGeeks')

const signature = crypto.sign(algorithm, data, privateKey)

const isVerified = crypto.verify(algorithm, data, publicKey, signature)

console.log(`Is signature verified:${isVerified}`)
```


Node.js - Crypto


Next.js 是基于 React 的框架，它提供了一个简单的构建工具，可以让你快速构建一个网站。

## 安装

> 前置条件：安装 Node.js、npm

```bash
npm init -y
npm install next react react-dom

# + "next": "^12.1.6",
# + "react": "^18.1.0",
# + "react-dom": "^18.1.0"
```

```json
{
  "dependencies": {
    "next": "^12.1.6",
    "react": "^18.1.0",
    "react-dom": "^18.1.0"
  },
  "name": "demo",
  "version": "1.0.0",
  "main": "index.js",
  "devDependencies": {},
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "pfan",
  "license": "ISC",
  "description": ""
}
```

添加`build`和`start`命令

```bash
{
  "dependencies": {
    "next": "^12.1.6",
    "react": "^18.1.0",
    "react-dom": "^18.1.0"
  },
  "name": "demo",
  "version": "1.0.0",
  "main": "index.js",
  "devDependencies": {},
  "scripts": {
    "build": "next build",
    "start": "next start"
  },
  "author": "pfan",
  "license": "ISC",
  "description": ""
}
```

## 创建`pages`目录

```bash
mkdir pages && cd pages && touch index.js
```

```js
function HomePage() {
  return <div>Welcome to Next.js!</div>
}

export default HomePage
```

## 启动服务

```bash
npm run dev

#npm run dev --port=8888
#
#> demo@1.0.0 dev
#> next dev
#
#ready - started server on 0.0.0.0:3000, url: http://localhost:3000
```

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


Next.js是基于React的框架，它提供了一个简单的构建工具，可以让你快速构建一个网站。