css-BFC


## 抽奖类型

- 圆形抽奖
- 方形抽奖
- 老虎机
- 刮刮卡

### 圆形抽奖

代码如下：

```js
// prefix补全
var CSSTransform = (function () {
  var _elementStyle = document.createElement('div').style
  var _vendor = (function () {
    var vendors = ['t', 'webkitT', 'MozT', 'msT', 'OT'],
      transform,
      i = 0,
      l = vendors.length
    for (; i < l; i++) {
      transform = vendors[i] + 'ransform'
      if (transform in _elementStyle)
        return vendors[i].substr(0, vendors[i].length - 1)
    }
    return false
  })()

  function _prefixStyle(style) {
    if (_vendor === false) return false
    if (_vendor === '') return style
    return _vendor + style.charAt(0).toUpperCase() + style.substr(1)
  }
  return _prefixStyle('transform')
})()

// 转盘旋转效果
var Lottery = function (el) {
  this.running = false
  this.el = $(el)[0]
  /*
	    旋转转盘至指定位置
	    参数：
	    giftIndex: 礼物的索引（从0开始到数组.length - 1）
	    endCallback：转盘旋转完成时的回调
	    */
  this.rotateToGift = function (giftIndex, endCallback) {
    if (typeof endCallback != 'function') return
    if (giftIndex < 0 || giftIndex > CNST_GIFTS.length - 1) return
    if (this.running) return
    this.running = true
    var degToRotate = (giftIndex + 1) * 45 + 360 * 3 - 22.5 //最少转3圈
    var rotatedDeg = 0
    var speed = 20 //deg
    var speedRatio = 1
    var _this = this

    function r() {
      _this.el.style[CSSTransform] = 'rotate(' + -rotatedDeg + 'deg)'
      rotatedDeg += speed * speedRatio
      if (rotatedDeg + 180 >= degToRotate)
        //开始减速
        speedRatio = (degToRotate - rotatedDeg) / 180
      if (rotatedDeg >= degToRotate - 0.5) {
        rotatedDeg = degToRotate
        _this.el.style[CSSTransform] = 'rotate(' + -rotatedDeg + 'deg)'
        _this.running = false
        endCallback()
      } else setTimeout(r, 1000 / 24)
    }
    r()
  }
}
```

**使用方法：**

```html
<div class="lottery">
  <div class="lottery-bg"></div>
  <button id="btnStart" class="button start" onClick="startLottery()"></button>
</div>
```

调用方法：

```js

var myLottery = new Lottery($(".lottery .lottery-bg"));//初始化转盘
myLottery.rotateToGift(giftIndex, function() {
	    //giftIndex为后端接口下发的奖品ID，function为回调函数
}
```

待续


移动端抽奖


process 对象是 Node 的一个全局对象，提供当前 Node 进程的信息。它可以在脚本的任意位置使用，不必通过 require 命令加载。该对象部署了 EventEmitter 接口

## 属性

- `arch`: 操作系统的架构，可能的值有 `x64`, `arm`, `arm64`, `ia32`
- `argv`: 包含命令行参数的数组
- `config`: 包含当前进程的配置信息
- `connected`: 当前进程是否连接到了网络
- `env`: 包含当前进程的环境变量
- `execArgv`: 包含当前进程的执行参数
- `execPath`: 包含当前进程的执行路径
- `exitCode`: 当前进程的退出代码
- `args`: 包含当前进程的参数
- `pid`: 当前进程的 pid
- `platform`: 操作系统平台，可能的值有 `darwin`, `freebsd`, `linux`, `sunos`, `win32`
- `release`: 操作系统的版本
- `version`: Node.js 的版本
- `versions`: 包含当前运行的 Node.js 版本信息

输出基本信息

```js
console.log(`Process Architecture: ${process.arch}`)
console.log(`Process PID: ${process.pid}`)
console.log(`Process Platform: ${process.platform}`)
console.log(`Process Version: ${process.version}`)
```

输出命令行参数：

```js
process.argv.forEach((value, index, array) => {
  console.log(`${index}: ${value}`)
})
```

## 方法

- `cwd()`: 返回当前进程的工作目录
- `chdir(directory)`: 改变当前进程的工作目录
- `nextTick(callback)`: 在下一个事件循环中执行回调函数
- `exit(code)`: 退出当前进程
- `getgid()`: 返回当前进程的用户组 id
- `getuid()`: 返回当前进程的用户 id
- `nextTick(callback)`: 在下一个事件循环中执行回调函数
- `on(event, listener)`: 监听进程事件
- `setgid(id)`: 设置当前进程的用户组 id
- `setuid(id)`: 设置当前进程的用户 id
- `uptime()`: 返回当前进程的运行时间

获取当前工作目录和运行时间

```js
console.log(`Current directory: ${process.cwd()}`)
console.log(`Uptime: ${process.uptime()}`)
```

[Node.js 文档](http://nodejs.cn/api/process.html)
[process 对象](https://javascript.ruanyifeng.com/nodejs/process.html)


process对象是 Node 的一个全局对象，提供当前 Node 进程的信息。它可以在脚本的任意位置使用，不必通过require命令加载。该对象部署了EventEmitter接口

Node.js - Process


**协议没看懂~**

> 协议规定了用来实现某一特定功能所必需的方法和属性。
> 任意能够满足协议要求的类型被称为遵循(conform)这个协议。
> 类，结构体或枚举类型都可以遵循协议，并提供具体实现来完成协议定义的方法和功能。

## 创建协议

```swift
protocol Identifiable {
    // 协议定义
    var id: String { get }
}
```

如果一个类型遵循协议，那么它必须提供协议中定义的所有要求。

```swift
struct User: Identifiable {
    var id: String
}
```

## 协议继承

协议之间可以继承，这样可以让遵循协议的类型拥有父协议中的属性和方法。

```swift
protocol Payable {
    func calculateWages() -> Int
}

protocol NeedsTraining {
    func study()
}

protocol HasVacation {
    func takeVacation(days: Int)
}

# 继承

protocol Payable: Payable, NeedsTraining, HasVacation {
    // 协议继承
}
```

## 扩展

`extension`允许向现有的类型添加方法，属性或者下标。类似于 js 的`prototype`。

```swift
extension Int {
    func squared() -> Int {
        return self * self
    }
}

let number = 8
number.squared() // 64
```

**不允许在扩展中添加存储属性**

```swift
extension Int {
    var isEven: Bool {
        return self % 2 == 0
    }
}
```

## 协议扩展

```swift
let pythons = ["Eric", "Graham", "John", "Michael", "Terry", "Terry"]
let beatles = Set(["John", "Paul", "George", "Ringo"])
```

Swift 的数组和集合都属于`Collection`，所以可以写个扩展来满足协议要求。

```swift
extension Collection {
    func summarize() {
        print("There are \(count) of us:")

        for name in self {
            print(name)
        }
    }
}

pythyon.summarize()
beatles.summarize()
```

## 总结

- 协议描述了一致类型必须具有的方法和属性，但不提供这些方法的实现。
- 您可以在其他协议之上构建协议，类似于类。
- 扩展允许您将方法和计算属性添加到特定类型，例如 Int.
- 协议扩展允许您向协议添加方法和计算属性。
- 面向协议的编程是将您的应用程序架构设计为一系列协议，然后使用协议扩展来提供默认方法实现的实践


协议规定了用来实现某一特定功能所必需的方法和属性。

Protocols - 协议


LEFT JOIN 是 PostgreSQL 支持的一种查询语句，用于从两个表中检索数据。

LEFT JOIN 允许您从两个表中检索数据，并且您可以通过指定条件来控制哪些行被包含在结果集中。在 LEFT JOIN 中，如果指定的条件无法在右表中匹配相应的行，则会返回空值。

例如，假设您有两个表，分别为“employees”和“departments”。employees 表包含员工的详细信息，departments 表包含部门的详细信息。下面是一个使用 LEFT JOIN 检索员工和部门信息的示例查询：

```sql
SELECT employees.name, departments.name
FROM employees
LEFT JOIN departments
ON employees.department_id = departments.id;
```

上面的查询会返回包含员工名称和部门名称的结果集。如果指定的条件无法在 departments 表中匹配相应的行，则会返回空值。

假设有两个表`A`和`B`

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

在`A`表中可能有 0 或多个行，在`B`表中可能有 0 或 1 个行。

要从表中选择表`A`可能有或没有相应的数据，可以使用`LEFT JOIN`

```sql
SELECT
	pka,
	c1,
	pkb,
	c2
FROM
	A
LEFT JOIN B ON pka = fka;
```

要使用左连接将表`A`和表`B`连接，执行如下步骤：

- `SELECT`，在子句中指定要选择数据的两个表中的列
- 在`FROM`指定左表
- 在关键词`ON`后指定右表


Postgresql INNER JOIN从多个表中选择数据。

Postgresql - LEFT JOIN


在 Node.js 应用程序中，事件和回调概念用于提供并发性。由于 Node.js 应用程序是单线程的，Node js 的每个 API 都是异步的。

因此，它使用异步函数来保持并发性。节点使用观察者模式。节点线程保持事件循环，在任何任务完成后，它会触发相应的事件，向事件侦听器函数发出执行信号。

## Node.js 中的事件

```js
var fs = require('fs')
var rs = fs.createReadStream('./demofile.txt')
rs.on('open', function () {
  console.log('The file is open')
})
```

## 事件模型

Node.js 有一个内置的模块，名为“ Events”，在这个模块中，可以创建、监听、销毁等事件。

使用 require ()方法引入`events`模块。此外，所有事件属性和方法都是 `EventEmitter` 对象的实例。

```js
var events = require('events')
var eventEmitter = new events.EventEmitter()
```

## 事件对象

可以使用 `EventEmitter` 对象将事件处理程序分配给自己的事件。

在下面的示例中，我们创建了一个函数，该函数将在`scream`事件被触发时执行。

```js
var events = require('events')
var eventEmitter = new events.EventEmitter()

//Create an event handler:
var myEventHandler = function () {
  console.log('I hear a scream!')
}

//Assign the event handler to an event:
eventEmitter.on('scream', myEventHandler)

//Fire the 'scream' event:
eventEmitter.emit('scream')
```


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

Node.js - Events


Spacing（间距）是指在网页设计和排版中，用于描述元素（如文本、图片、容器等）之间的距离的一种概念。它可以通过 CSS 属性来设置，通常包括以下几种属性：

- margin（外边距）：用于设置元素与其它元素之间的距离，即元素外部空白区域与周围元素之间的距离。它可以设置四个方向的值，分别为 margin-top、margin-right、margin-bottom 和 margin-left。如果只设置一个值，它将被应用于所有四个方向；如果设置两个值，则第一个值应用于 top 和 bottom，第二个值应用于 left 和 right；如果设置三个值，则第一个值应用于 top，第二个值应用于 left 和 right，第三个值应用于 bottom。如果设置四个值，则分别应用于 top、right、bottom 和 left。
- padding（内边距）：用于设置元素内部空白区域与元素内容之间的距离，即元素内容区域与元素边界之间的距离。它可以设置四个方向的值，分别为 padding-top、padding-right、padding-bottom 和 padding-left。如果只设置一个值，它将被应用于所有四个方向；如果设置两个值，则第一个值应用于 top 和 bottom，第二个值应用于 left 和 right；如果设置三个值，则第一个值应用于 top，第二个值应用于 left 和 right，第三个值应用于 bottom。如果设置四个值，则分别应用于 top、right、bottom 和 left。
- line-height（行高）：用于设置文本行之间的距离，即每行文本的高度。它通常被用于控制段落和标题的行间距。它可以设置为一个无单位的数字值，表示倍数关系，如 1.5 表示当前字体大小的 1.5 倍；也可以设置为具有单位的像素或 em 等值。

除了这些属性外，还有一些其它的间距相关的属性，如：

- border-spacing：用于设置表格中的单元格之间的距离，即单元格边框之间的距离。
- grid-gap：用于设置网格布局中各个网格之间的距离，即网格行列之间的距离。
- column-gap：用于设置多列布局中各个列之间的距离，即列与列之间的距离。

以下是一个使用间距属性的示例代码，用于在网页中创建一个简单的图片库：

```html
<div class="image-gallery">
  <div class="image-container">
    <img src="image1.jpg" alt="Image 1">
  </div>
  <div class="image-container">
    <img src="image2.jpg" alt="Image 2">
  </div>
  <div class="image-container">
    <img src="image3.jpg" alt="Image 3">
  </div>
  <div class="image-container">
    <img src="image4.jpg" alt="Image 4">
  </div>
</div>
```

```css
.image-gallery {
  display: flex;
  flex-wrap: wrap;
  justify-content: center;
  gap: 20px;
}

.image-container {
  width: 200px;
  height: 200px;
  overflow: hidden;
}

.image-container img {
  width: 100%;
  height: 100%;
  object-fit: cover;
}
```

在这个示例中，我们使用了以下的间距相关属性：

- gap：用于设置元素之间的间距，这里用于设置图片之间的间距。
- width 和 height：用于设置图片容器的宽度和高度，这里设置为 200px，以便容纳图片。
- overflow：用于设置图片容器的溢出行为，这里设置为 hidden，以便保证图片不会溢出容器。
- object-fit：用于设置图片的填充方式，这里设置为 cover，以便让图片填充整个容器。

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