如何校验URLs？


`JavaScript`没有二进制数据类型，`buffer`是`Node.js`提供的专门用来存放二进制数据的缓存区。

## 创建 buffer

```js
// 创建10字节的未启动的缓存区
var buf = Buffer.alloc(10)

// 从数组创建缓存区
var buf = Buffer.from([10, 20, 30, 40, 50])

// 从字符串创建缓存区
var buf = Buffer.from('Node.js', 'utf-8')
```

## 写入 buffer

语法：`buf.write(string[, offset[, length]][, encoding])`

```js
var buf = Buffer.alloc(256)
len = buf.write('Node.js')
console.log(len) // 7
```

## 读取 buffer

语法：`buf.toString(encoding,start,end)`

- `encoding`：使用编码，默认`utf-8`
- `start`：读取初始索引位置
- `end`：读取结束位置

```js
buf = Buffer.alloc(26)
for (var i = 0; i < 26; i++) {
  buf[i] = i + 97
}

console.log(buf.toString('ascii')) // 输出: abcdefghijklmnopqrstuvwxyz
console.log(buf.toString('ascii', 0, 5)) //使用 'ascii' 编码, 并输出: abcde
console.log(buf.toString('utf8', 0, 5)) // 使用 'utf8' 编码, 并输出: abcde
console.log(buf.toString(undefined, 0, 5)) // 使用默认的 'utf8' 编码, 并输出: abcde
```

## 将 buffer 转换为 json 对象

语法：`buf.toJson`

```js
const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5])
const json = JSON.stringify(buf)

// 输出: {"type":"Buffer","data":[1,2,3,4,5]}
console.log(json)

const copy = JSON.parse(json, (key, value) => {
  return value && value.type === 'Buffer' ? Buffer.from(value.data) : value
})

// 输出: <Buffer 01 02 03 04 05>
console.log(copy)
```

## buffer 合并

语法：`Buffer.contact(list,totalLength)`

- `list`：用于合并的`Buffer`对象数组列表
- `totalLength`：合并后`Buffer`对象的总长度

```js
var buf1 = Buffer.from('Hello')
var buf2 = Buffer.from(' World!')
var buf3 = Buffer.concat([buf1, buf2])

console.log(buf3) //<Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64 21>
```

## buffer 比较

语法：`buf.compare(..)`

返回数字，0 表示相同，小于 0 表示 buf 在 bufToCompare 之前，大于 0 则相反

```js
var buf = Buffer.from('Hello')
var bufToCompare = Buffer.from('hello')

var result = buf.compare(bufToCompare)
console.log(result) // -1
```

## buffer 拷贝

语法：`buf.copy(target,targetStart,sourceStart,sourceEnd)`

- `target`：要拷贝的`Buffer`对象
- `targetStart`：默认 0
- `sourceStart`：默认 0
- `sourceEnd`：默认 0

```js
var buf = Buffer.from('Hello')
var bufToCopy = Buffer.from('World')

bufToCopy.copy(buf, 2)
console.log(buf.toString()) //HeWor
```

## buffer 切片

语法：`buf.slice(start,end)`

- `start`：切片初始位置，默认 0
- `end`：切片结束位置，默认为`buffer.length`

```js
var buf = Buffer.from('Hello World')
var result = buf.slice(0, 5)
console.log(result.toString()) //Hello
```

[入门教程](http://nodejs.cn/learn/nodejs-buffers)
[Node.js 文档](http://nodejs.cn/api/buffer.html)


buffer是Node.js提供用来存放二进制数据的缓存区

Node.js - Buffers


在 Swift 中，取消初始化通常指的是在初始化器中出现了错误或某些情况下无法完成初始化时，通过返回 nil 或抛出异常来表示初始化的失败或取消。

取消初始化的常用方法有两种：

使用可失败初始化器（Failable initializer）：可失败初始化器是指在初始化时可能会失败并返回 nil 的初始化器。可以通过在初始化方法后面加上问号来声明可失败初始化器。

```swift
class Person {
    var name: String

    init?(name: String) {
        if name.isEmpty {
            return nil
        }
        self.name = name
    }
}
```

在上述示例中，如果传入的 name 为空，则初始化失败并返回 nil。

使用抛出错误（Throwing Errors）：抛出错误是指在初始化时如果遇到错误就会抛出一个异常，这可以让调用者来决定如何处理错误。可以通过在初始化方法中使用 throw 语句抛出一个异常。

```swift
enum InvalidInputError: Error {
  case emptyName
}

class Person {
  var name: String

    init(name: String) throws {
        if name.isEmpty {
            throw InvalidInputError.emptyName
        }
        self.name = name
    }
}
```

在上述示例中，如果传入的 name 为空，则会抛出 InvalidInputError.emptyName 异常，调用者可以使用 do-catch 语句来处理异常。

当然，取消初始化并不是一种推荐的行为，我们应该尽量避免在初始化器中使用返回 nil 或抛出异常的方式来取消初始化，而应该尽量保证初始化器的顺利完成，或者在初始化器中处理可能会导致初始化失败的情况。


在 Swift 中，取消初始化通常指的是在初始化器中出现了错误或某些情况下无法完成初始化时，通过返回 nil 或抛出异常来表示初始化的失败或取消。

Swift - 取消初始化


JavaScript 中的作用域绑定是指确定变量和函数在代码中的可见性和访问权限的机制。作用域定义了变量和函数的可访问范围，以及它们在代码中的生命周期。

JavaScript 中有两种主要的作用域绑定机制：词法作用域和动态作用域。

## 词法作用域

词法作用域是在代码编写阶段确定的作用域，它基于变量和函数在源代码中的位置进行绑定。也就是说，词法作用域是由代码的结构来决定的，不会被函数调用的位置或上下文影响。

在词法作用域中，当定义一个变量或函数时，它们会被绑定到最近的包含它们的函数或全局作用域中。当在代码中引用一个变量或函数时，JavaScript 解释器会按照词法结构从内层作用域向外层作用域进行查找，直到找到匹配的标识符或达到全局作用域。

示例：

```javascript
var globalVariable = 'Global'

function outerFunction() {
  var outerVariable = 'Outer'

  function innerFunction() {
    var innerVariable = 'Inner'
    console.log(globalVariable) // 可以访问全局变量
    console.log(outerVariable) // 可以访问外层函数的变量
    console.log(innerVariable) // 可以访问当前函数的变量
  }

  innerFunction()
}

outerFunction()
```

## 动态作用域

动态作用域是在运行时确定的作用域，它基于当前的执行上下文和调用链来绑定变量和函数。与词法作用域不同，动态作用域的可见性和访问权限取决于函数调用的位置和上下文。

JavaScript 并没有内置的动态作用域机制，它使用的是词法作用域。但是，一些编程语言（如 Bash 脚本）使用动态作用域来确定变量的可见性。

JavaScript 的作用域绑定机制是词法作用域，它基于代码的结构来决定变量和函数的可见性和访问权限。词法作用域通过将变量和函数绑定到最近的包含它们的作用域来实现。动态作用域是一种在运行时确定作用域的机制，但 JavaScript 并不支持动态作用域。


作用域绑定


在 Swift 中，下标(subscript)是访问集合、列表或序列等值的快捷方式。类似于使用索引访问数组元素，下标可以使我们通过自定义的方式访问和修改集合、列表或序列中的元素。下标可以看作是一个参数化的属性，可以使用中括号([])来访问。

Swift 中的下标可以定义为只读、读写或可写，类似于计算属性。根据需要，下标可以接受任意数量的参数，并且参数可以是任何类型。下标的语法如下所示：

```swift
subscript(index: Int) -> Int {
    get {
        // 返回给定索引的值
    }
    set(newValue) {
        // 在给定索引处设置一个新值
    }
}
```

在上面的示例中，我们定义了一个接受一个整数参数并返回一个整数值的下标。下标有一个 get 和一个 set 方法。get 方法返回给定索引的值，set 方法将给定索引处的元素设置为新值。

下标也可以使用多个参数，如下所示：

```swift
struct Matrix {
    let rows: Int, columns: Int
    var grid: [Double]

    init(rows: Int, columns: Int) {
        self.rows = rows
        self.columns = columns
        grid = Array(repeating: 0.0, count: rows * columns)
    }

    subscript(row: Int, column: Int) -> Double {
        get {
            assert(row >= 0 && row < rows && column >= 0 && column < columns, "Index out of range")
            return grid[(row * columns) + column]
        }
        set {
            assert(row >= 0 && row < rows && column >= 0 && column < columns, "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
}

var matrix = Matrix(rows: 2, columns: 2)
matrix[0, 0] = 1.0
matrix[0, 1] = 2.0
matrix[1, 0] = 3.0
matrix[1, 1] = 4.0

print(matrix[0, 0])
print(matrix[0, 1])
print(matrix[1, 0])
print(matrix[1, 1])
```

在上面的示例中，我们定义了一个 Matrix 结构体，它有 rows、columns 和 grid 三个属性。我们还定义了一个接受两个整数参数并返回一个 Double 类型值的下标。get 方法返回给定索引处的元素，set 方法将给定索引处的元素设置为新值。在这里，我们使用了断言来确保给定的索引处于合法范围内，否则会抛出一个运行时错误。

下标是 Swift 语言中非常有用的功能，使我们可以轻松地访问和修改集合、列表或序列中的元素。下标可以使用任意数量和任意类型的参数，因此可以根据需要进行自定义。通过定义下标，我们可以使代码更加简洁、直观和易于理解。


在 Swift 中，下标(subscript)是访问集合、列表或序列等值的快捷方式

Swift - 下标


`Text` 视图是 `SwiftUI` 用户界面中最常用的元素之一。它们允许你向你的应用程序中添加文本，比如标签、标题、描述等等。在 `SwiftUI` 中，`Text`视图易于使用，只需要最少的代码，并提供很多的自定义选项。

若要创建 `Text` 视图，请使用 `Text` 初始值设定项并提供要在其中显示的文本。下面是如何创建显示简单消息的 `Text` 视图的示例:

```swift
struct ContentView: View {
  var body: some View {
    Text("Hello, World!")
  }
}
```

在 `ContentView` 结构中，我们定义`body`计算属性，该属性返回一个视图。在这里，我们使用 `Text` 视图创建一个文本视图的新实例，并使用“ `Hello，World!`”作为它的内容。

## 自定义文本视图

`Text` 视图是一个灵活而轻量级的视图，允许您自定义其字体、样式、颜色、大小、行间距以及更多使用修饰符。下面的示例说明如何通过添加`.font()`修饰语:

```swift
struct ContentView: View {
  var body: some View {
    Text("Hello, World!")
      .font(.largeTitle)
  }
}
```

上面的代码使用字体修饰符将 `Text` 视图的字体大小和样式定义为`.largeTitle`。是 `SwiftUI` 预定义的文本样式之一。这只是 `Text` 视图可以合并的众多修饰符之一。


文本视图是 SwiftUI 用户界面中最常用的元素之一。

Swift - 在 SwiftUI 中添加文本视图


## 创建列表

```python
names = ['Michael', 'Bob', 'Tracy']
nums = [1, 2, 3]
```

也可以使用其他方法`split()`创建

```python
line = 'Hello World!'
row = line.split(' ')
row # ['Hello', 'World!']
```

## 列表操作

```python
names.append('Adam') # 在末尾添加元素
names.insert(1, 'Jack') # 在指定位置添加元素
```

使用`+`连接两个列表

```python
s=[1,2,3]
t=[4,5,6]
s+t # [1,2,3,4,5,6]
```

列表索引从 0 开始

```python
names = ['Michael', 'Bob', 'Tracy']
names[0] # Michael
names[1] # Bob
names[-1] # Tracy
```

使用索引覆盖元素

```python
names[0] = 'Adam' # 修改第一个元素
names # ['Adam', 'Bob', 'Tracy']
```

使用`len`获取列表长度

```python
len(names) # 3
```

使用`in`判断元素是否在列表中

```python
'Adam' in names # True
'manon' in names # False
```

## 列表的循环

使用`for`循环遍历列表

```python
for name in names:
    print(name)
```

查找索引值

```python
names.index('Bob') # 1
```

## 移除元素

使用`del`或`remove`删除元素

```python
names.remove('Bob') # 删除第一个 Bob
del names[0] # 删除第一个元素
```

## 列表的排序

使用`sort`对列表进行排序

```python
s = [10, 1, 7, 3]
s.sort()                    # [1, 3, 7, 10]

# Reverse order
s = [10, 1, 7, 3]
s.sort(reverse=True)        # [10, 7, 3, 1]

# It works with any ordered data
s = ['foo', 'bar', 'spam']
s.sort()                    # ['bar', 'foo', 'spam']
```

使用`sorted`创建新的列表，不会修改原列表

```python
t = sorted(s)
```


列表（List）是 python 的基本类型