闭包


在 Swift 中，继承(Inheritance)是一种定义新类的方法，使其从现有类继承属性和方法。新类称为子类(Subclass)，被继承的类称为父类(Superclass)。

子类可以重写(override)父类的属性和方法，也可以添加新的属性和方法。子类还可以继续被其他类继承，从而形成类的层次结构。

在 Swift 中，继承可以通过在类的定义中使用冒号(:)来实现。例如：

```swift
class Animal {
var name: String = ""

    func makeSound() {
        // 产生动物叫声
    }
}

class Dog: Animal {
var breed: String = ""

    override func makeSound() {
        // 产生狗叫声
    }
}
```

在上面的示例中，我们定义了两个类 Animal 和 Dog。Dog 继承自 Animal，并添加了一个名为 breed 的属性。Dog 还重写了 Animal 的 makeSound() 方法。

通过继承，Dog 类获得了 Animal 类中的所有属性和方法。这意味着，我们可以在 Dog 类中使用 Animal 类中定义的属性和方法，而不必重复编写相同的代码。此外，通过重写 makeSound() 方法，我们可以根据需要修改 Dog 类的行为。

在 Swift 中，我们还可以使用关键字 final 来防止子类重写父类的属性或方法。例如：

```swift
class Animal {
final var name: String = ""

    final func makeSound() {
        // 产生动物叫声
    }
}

class Dog: Animal {
// 无法重写 name 或 makeSound 方法
}
```

在上面的示例中，我们使用关键字 final 来标记 name 和 makeSound() 方法，从而防止子类重写这些属性和方法。

继承是 Swift 语言中强大而灵活的功能之一。通过继承，我们可以轻松地扩展现有类的功能，从而构建出更复杂和强大的程序。同时，继承也需要谨慎使用，以避免出现代码的复杂性和耦合度过高等问题。


在 Swift 中，继承(Inheritance)是一种定义新类的方法，使其从现有类继承属性和方法。新类称为子类(Subclass)，被继承的类称为父类(Superclass)。

Swift - 继承


在 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


![集合引用类型](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/集合引用类型.png)

## Object

> 任何非原始类型的值（字符串，数字，布尔值，符号，null 或未定义）都是对象，数组和函数也不例外。

内置属性

1. Object.length=1
2. Object.prototype

静态方法

1. Object.assign() **_ES2015_** //通过复制一个或多个对象来创建一个新的对象。
2. Object.create() //使用指定的原型对象和属性创建一个新对象。
3. Object.defineProperty() //给对象添加一个属性并指定该属性的配置。
4. Object.defineProperties() //给对象添加多个属性并分别指定它们的配置。
5. Object.entries() **_ES2017_** //返回给定对象自身可枚举属性的 [key, value] 数组。
6. Object.freeze() //冻结对象：其他代码不能删除或更改任何属性。
7. Object.getOwnPropertyDescriptor() //返回对象指定的属性配置。
8. Object.getOwnPropertyNames() //返回一个数组，它包含了指定对象所有的可枚举或不可枚举的属性名。
9. Object.getOwnPropertySymbols() //返回一个数组，它包含了指定对象自身所有的符号属性。
10. Object.getPrototypeOf() //返回指定对象的原型对象。
11. Object.is() **_ES2015_** //比较两个值是否相同。所有 NaN 值都相等（这与==和===不同）。
12. Object.isExtensible() //判断对象是否可扩展。
13. Object.isFrozen() //判断对象是否已经冻结。
14. Object.isSealed() //判断对象是否已经密封。
15. Object.keys() //返回一个包含所有给定对象自身可枚举属性名称的数组。
16. Object.preventExtensions() //防止对象的任何扩展。
17. Object.seal() //防止其他代码删除对象的属性。
18. Object.setPrototypeOf() **_ES2015_** //设置对象的原型（即内部 [[Prototype]] 属性）。
19. Object.values() //返回给定对象自身可枚举值的数组。

Object 实例和 Object 原型对象

> JavaScript 中的所有对象都来自 Object；所有对象从 Object.prototype 继承方法和属性，尽管它们可能被覆盖。

```js
Object.prototype.constructor //特定的函数，用于创建一个对象的原型。
```

实例方法

1. Object.prototype.hasOwnProperty() //返回一个布尔值 ，表示某个对象是否含有指定的属性，而且此属性非原型链继承的。
2. Object.prototype.isPrototypeOf() //返回一个布尔值，表示指定的对象是否在本对象的原型链中。
3. Object.prototype.propertyIsEnumerable() //判断指定属性是否可枚举，内部属性设置参见 ECMAScript [[Enumerable]] attribute 。
4. Object.prototype.toLocaleString() //直接调用 toString()方法。
5. Object.prototype.toString() //返回对象的字符串表示。
6. Object.prototype.valueOf() //返回指定对象的原始值。

创建对象

```js
const person = {}
typeof person //object
```

### 使用 Object 全局函数

```js
const person = Object()
typeof person //object
```

### 使用 Object 构造器

```js
const person = new Object()
typeof person //object
```

### 使用 Object.create()

```js
const car = Object.create()
```

```js
const person = {
  age: 36,
  name: 'funny',
  speak: () => {
    //speak
  }
}

const person = Object({
  age: 36,
  name: 'funny',
  speak: () => {
    //speak
  }
})

const person = new Object({
  age: 36,
  name: 'funny',
  speak: () => {
    //speak
  }
})
```

### Object.assign

```js
const copied = Object.assign({}, target1, target2, ...target)
```

> Object.assign-将一个或多个对象的所有可枚举属性复制到另一个对象中。浅拷贝，复制对象引用而非对象本身。

```js
const original = {
  name: 'Fiesta',
  car: {
    color: 'blue'
  }
}
const copied = Object.assign({}, original)

original.name = 'Focus'
original.car.color = 'yellow'

copied.name //Fiesta
copied.car.color //yellow
```

### Object.create

```js
const newObject = Object.create(prototype)

const newObject = Object.create(prototype, newProperties)
```

> 使用指定原型创建新的对象，可以指定第二个参数来向对象添加新属性

```js
const animal = {}
const dog = Object.create(animal)

const animal = {}
const dog = Object.create(animal, {
  breed: {
    value: 'Siberian Husky'
  }
})
console.log(dog.breed) //'Siberian Husky'
```

### Object.defineProperty

> 直接在一个对象上定义一个新属性，或者修改一个对象的现有属性， 并返回这个对象

```js
const dog = {}
Object.defineProperty(dog, 'breed', {
  value: 'Siberian Husky'
})
console.log(dog.breed) //'Siberian Husky'
```

扩展：[vue 原理之-神奇的 Object.defineProperty]("https://zhuanlan.zhihu.com/p/29066270")

### Object.defineProperties

> 直接在一个对象上定义新的属性或修改现有属性，并返回该对象

```js
const dog = {}
Object.defineProperties(dog, {
  breed: {
    value: 'Siberian Husky'
  }
})
console.log(dog.breed) //'Siberian Husky'
```

### Object.entries()

> ES2017,返回自身可枚举属性的键值对数组

```js
const person = {name: 'Fred', age: 87}
Object.entries(person) // [['name', 'Fred'], ['age', 87]]

const people = ['Fred', 'Tony']
Object.entries(people) // [['0', 'Fred'], ['1', 'Tony']]
```

### Object.freeze()

> 冻结对象，冻结后不能再添加或修改

```js
const dog = {}
dog.breed = 'Siberian Husky'
const myDog = Object.freeze(dog)

Object.isFrozen(dog) //true
Object.isFrozen(myDog) //true
dog === myDog //true

dog.name = 'Roger' //TypeError: 无法添加name属性，dog是不可扩展的
```

### Object.getOwnPropertyDescriptor()

> 返回自由属性描述符

```js
const dog = {}
Object.defineProperties(dog, {
  breed: {
    value: 'Siberian Husky'
  }
})
Object.getOwnPropertyDescriptor(dog, 'breed')
/*
{
  value: 'Siberian Husky',
  writable: false,
  enumerable: false,
  configurable: false
}
*/
```

### Object.getOwnPropertyNames()

> 返回一个由指定对象的所有自身属性的属性名（包括不可枚举属性但不包括 Symbol 值作为名称的属性）组成的数组

```js
const dog = {}
dog.breed = 'Siberian Husky'
dog.name = 'Roger'

Object.getOwnPropertyNames(dog) //[ 'breed', 'name' ]
```

### Object.getOwnPropertySymbols()

> 返回一个给定对象自身的所有 Symbol 属性的数

```js
const dog = {}
const r = Symbol('Roger')
const s = Symbol('Syd')
dog[r] = {
  name: 'Roger',
  age: 6
}
dog[s] = {
  name: 'Syd',
  age: 5
}

Object.getOwnPropertySymbols(dog) //[ Symbol(Roger), Symbol(Syd) ]
```

### Object.getPrototypeOf()

> 返回指定对象的原型（内部[[Prototype]]属性的

```js
const animal = {}
const dog = Object.create(animal)
const prot = Object.getPrototypeOf(dog)

animal === prot //true

//如果对象没有原型，将返回null
Object.prototype //{}
Object.getPrototypeOf(Object.prototype) //null
```

### Object.is()

> 判断两个值是否相等

- 两个值都是 undefined
- 两个值都是 null
- 两个值都是 true 或者都是 false
- 两个值是由相同个数的字符按照相同的顺序组成的字符串
- 两个值指向同一个对象
- 两个值都是数字并且
  - 都是正零 +0
  - 都是负零 -0
  - 都是 NaN
  - 都是除零和 NaN 外的其它同一个数字

```js
Object.is(a, b)
```

### Object.isExtensible()

> 判断一个对象是否是可扩展的，返回布尔值。任何对象都是可扩展，除非使用了 Object.freeze()、Object.seal()、Object.preventExtensions()

### Object.isFrozen()

> 判断一个对象是否被冻结，返回布尔值

```js
const dog = {}
dog.breed = 'Siberian Husky'
const myDog = Object.freeze(dog)
Object.isFrozen(dog) //true
Object.isFrozen(myDog) //true
dog === myDog //true
```

### Object.isSealed()

> 判断一个对象是否被密封，返回布尔值

```js
const dog = {}
dog.breed = 'Siberian Husky'
const myDog = Object.seal(dog)
Object.isSealed(dog) //true
Object.isSealed(myDog) //true
dog === myDog //true
```

### Object.keys()

> 返回对象的自身可枚举属性组成的数组

```js
const car = {
  color: 'Blue',
  brand: 'Ford',
  model: 'Fiesta'
}

Object.keys(car) //[ 'color', 'brand', 'model' ]
```

### Object.preventExtensions()

> 阻止对象扩展，但可以删除属性

```js
const dog = {}
dog.breed = 'Siberian Husky'
Object.preventExtensions(dog)

dog.name = 'Roger' //TypeError: Cannot add property name, object is not extensible

delete dog.name
dog //{ breed: 'Siberian Husky' }
```

### Object.seal()

> 与 Object.freeze（）类似，但不会使属性不可写。仅阻止添加或删除属性。与 Object.preventExtensions（）类似，但也不允许删除属性：

```js
const dog = {}
dog.breed = 'Siberian Husky'
Object.seal(dog)
dog.breed = 'Pug'
dog.name = 'Roger' //TypeError: Cannot add property name, object is not extensible
```

### Object.values()

> 对象自身的所有可枚举属性值的数组

```js
const person = {name: 'Fred', age: 87}
Object.values(person) // ['Fred', 87]

const people = ['Fred', 'Tony']
Object.values(people) // ['Fred', 'Tony']
```

### Object.hasOwnProperty()

> 判断对象自身是否有某个值，返回布尔值

```js
const person = {name: 'Fred', age: 87}
person.hasOwnProperty('name') //true
person.hasOwnProperty('job') //false
```

### Object.isPrototypeOf()

> 测试一个对象是否存在于另一个对象的原型链上

```js
const Animal = {
  isAnimal: true
}

const Mammal = Object.create(Animal)
Mammal.isMammal = true

Animal.isPrototypeOf(Mammal) //true

const dog = Object.create(Animal)
Object.setPrototypeOf(dog, Mammal)

Animal.isPrototypeOf(dog) //true
Mammal.isPrototypeOf(dog) //true
```

### Object.propertyIsEnumerable()

> 判断对象的属性是否可枚举，返回布尔值

```js
const person = {name: 'Fred'}

Object.defineProperty(person, 'age', {
  value: 87,
  enumerable: false
})

person.propertyIsEnumerable('name') //true
person.propertyIsEnumerable('age') //false
```

### Object.toLocaleString()

```js
const person = {name: 'Fred'}
person.toLocaleString() //[object Object]
```

### Object.toString()

```js
const person = {name: 'Fred'}
person.toString() //[object Object]
```

### Object.valueOf()

> 返回指定对象的原始值

```js
const person = {name: 'Fred'}
person.valueOf() //{ name: 'Fred' }
```

## Array

属性

1. Array.length - 静态属性，值为 1
2. Array.prototype - 数组的原型对象

方法

1. Array.from - 从类数组对象或者可迭代对象中创建一个新的数组实例
2. Array.of - 根据一组参数来创建新的数组实例，支持任意的参数数量和类型
3. Array.isArray - 判断是否为数组

### 实例属性

1. Array.prototype.length - 空数组，值为 0
2. Array.prototype.constructor - 所有的数组实例都继承了这个属性，值为 Array

### 实例方法

#### 修改器方法 - 改变调用它们的对象自身的值

- Array.prototype.copyWithin //将数组 copy 到另一个数组，并覆盖原值
- Array.prototype.fill //填充数组
- Array.prototype.pop //删除数组最后一个值，并返回该值
- Array.prototype.push //向数组最后添加一个新的元素或多个元素，并返回数组的长度
- Array.prototype.reverse //颠倒数组
- Array.prototype.shift //删除数组第一个元素并返回该元素
- Array.prototype.sort //排序
- Array.prototype.splice //在数组任意位置添加或删除元素
- Array.prototype.unshift //在数组开头添加一个或多个元素并返回数组长度

#### 访问方法 - 不会改变调用它们的对象自身的值，只会返回新数组或期望值

- Array.prototype.concat //返回当前数组和其他数组的组合
- Array.prototype.includes //数组是否包含某个值，返回 true/false
- Array.prototype.join //返回数组所有元素组成的字符串
- Array.prototype.slice //截取数组的某一段
- Array.prototype.toString //转换成字符串
- Array.prototype.toLocalString //转换成本地字符串
- Array.prototype.indexOf //返回数组中第一个与指定值相等的索引
- Array.prototype.lastIndexOf //返回数组中最后一个与指定值相等的索引

#### 迭代方法

- Array.prototype.forEach //为数组中每个元素执行一次回调函数
- Array.prototype.entries //返回数组元素的键值对
- Array.prototype.every //如果每个元素都满足回调函数就返回 true，否则返回 false
- Array.prototype.some //如果数组中元素至少有一个满足回调函数就返回 true，否则返回 false
- Array.prototype.filter //过滤数组中满足回调函数的元素
- Array.prototype.find //查找数组中满足回调函数的元素，如果没有则返回 undefined
- Array.prototype.findIndex //返回数组中满足回调函数的索引，没有则返回-1
- Array.prototype.keys //返回数组中的键
- Array.prototype.map //返回一个由回调函数组成的新数组
- Array.prototype.reduce //从右向左为每个元素执行一次回调函数，并将上次回调函数的返回值暂存，然后传递给下一个回调函数
- Array.prototype.reduceRight //与 reduce 相反方向
- Array.prototype.values //返回数组中的值

### 四种合并数组的方法

1. 循环

```js
function push(fromArray, toArray) {
  for (let i = 0, len = fromArray.length; i < len; i++) {
    toArray.push(fromArray[i])
  }
  return toArray
}

var array1 = [1, 2, 3, 4, 5]
var array2 = [6, 7, 8, 9, 10]
var array3 = []
push(array1, array3)
push(array2, array3)
```

2. 解构

```js
var array1 = [1, 2, 3, 4, 5]
var array2 = [6, 7, 8, 9, 10]
var array3 = [...array1, ...array2]
var array3 = Array.of(...array2, ...array1)
array3 // [1,2,3,4,5,6,7,8,9,10];
```

3. concat

```js
var array1 = [1, 2, 3, 4, 5]
var array2 = [6, 7, 8, 9, 10]

var array3 = array1.concat(array2)
// or
var array3 = [].concat(array1, array2)
```

4. reduce

```js
var array1 = [1,2,3,4,5];
var array2 = [6,7,8,9,10];
var array3 = array2.reduce((newArray, item) => {
          newArray.push(item);
          return newArray;
 ), array1);
```

## 定型数组

## Map、WeakMap

## Set、WeakSet

## 迭代、扩展操作


Javascript - 集合引用类型


在前一篇文章介绍了[Adding browser notification](/blog/translate/build-chrome-extenstions/adding-browser-notification)，这篇将学习如何创建重复的通知。

## 创建重复通知

为了实现重复通知，我们必须利用[alarm api](https://developer.chrome.com/docs/extensions/reference/alarms/)。这允许我们创建可以在指定时间发起通知。

首先更新`manifest.json`，以便获取使用`alarm`权限

```json
{
  "permissions": ["alarm", "notifications"]
}
```

定时发起通知需要后台运行的服务，在 v3 manifest，可以注册一个后台服务

```json
{
  "background": {
    "service_worker": "background.js"
  }
}
```

然后修改`App.jsx`

```jsx
export function App() {
  const createNotification = () => {
    chrome.alarms.create({
      periodInMinutes: 1
    })
    window.close()
  }

  const stopNotification = () => {
    chrome.alarms.clearAll()
    window.close()
  }
  return (
    <div className="flex flex-col items-center justify-center w-screen h-auto bg-indigo-400 p-4">
      <button
        className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 text-2xl px-4 rounded"
        onClick={createNotification}
      >
        Motivate me 🎉
      </button>
      <br />
      <button
        className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 text-2xl px-4 rounded"
        onClick={stopNotification}
      >
        Stop motivating me 😅
      </button>
    </div>
  )
}
```

修改`background.js`

```js
chrome.alarms.onAlarm.addListener(() => {
  chrome.notifications.create({
    type: 'basic',
    iconUrl: 'icons/icon-48.png',
    title: 'Hi there 👋',
    message: 'Just a reminder that you rock!',
    buttons: [{title: 'I know ☺️'}],
    priority: 0
  })
})
```

## Source Code

[【Source Code】](https://github.com/rebelchris/popup-extension/tree/weather)


基于react、tailwindcss开发自己的chrome插件

Chrome插件开发 - Repeating notifications


在此之前，我们学习了以下几个关于 chrome 插件开发的文章：

- [First extension](/blog/translate/build-chrome-extensions/first-extension)
- [New Tab](/blog/translate/build-chrome-extensions/new-tab)
- [Add Tailwind](/blog/translate/build-chrome-extensions/add-tailwind)
- [Add React](/blog/translate/build-chrome-extensions/spicing-with-react)

这篇文章学习创建弹窗插件（点击插件图标时出现）

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

## 结构

创建目录，然后初始化

```bash
mkdir popup-extension
cd popup-extension
npm init -y
```

安装依赖

```bash
npm i react react-dom tailwindcss vite

npm i -D @vitejs/plugin-react postcss-cli

npx tailwind init
```

- [React、React-dom](/blog/translate/build-chrome-extensions/spicing-with-react) for framework
- [Tailwind](/blog/translate/build-chrome-extensions/add-tailwind) for css
- [vite](/blog/translate/build-chrome-extensions/parcel-to-vite) for build

`npx tailwind init`将会创建`tailwind.config.js`，内容如下：

```js
/** @type {import('tailwindcss').Config} */
module.exports = {
  content: ['src/*.jsx'],
  theme: {
    extend: {}
  },
  variants: {
    extend: {}
  },
  plugins: []
}
```

创建`.postcssrc.json`

```json
{
  "plugins": {
    "tailwindcss": {}
  }
}
```

创建`css/style.css`

```css
@tailwind base;
@tailwind components;
@tailwind utilities;
```

创建`vite.config.js`

```js
import {defineConfig} from 'vite'
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [react()]
})
```

修改`package.json`，添加如下`scripts`

```json
{
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "preview": "vite preview"
  }
}
```

创建`public/manifest.json`

```json
{
  "manifest_version": 3,
  "version": "1.0",
  "name": "Popup Extension",
  "description": "A demo popup experience",
  "action": {
    "default_icon": "icons/icon-48.png",
    "default_popup": "index.html"
  },
  "icons": {
    "48": "icons/icon-48.png"
  }
}
```

创建`index.html`

```html
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="ie=edge" />
    <title>DDT Popup</title>
    <link rel="stylesheet" type="text/css" href="./css/style.css" />
  </head>
  <body>
    Hello world 👋
  </body>
</html>
```

假如现在构建并加载插件，当前 Popup 插件将会展示如下：

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

添加`Tailwind`、`React`，修改`index.html`

```html
<body>
  <div id="app"></div>
  <script type="module" src="src/index.jsx"></script>
</body>
```

创建`src`，并在`src`下添加`index.jsx`

```jsx
import ReactDOM from 'react-dom'
import {App} from './App'

const app = document.getElementById('app')
ReactDOM.render(<App />, app)
```

创建`App.jsx`

```jsx
import Counter from './Counter'

export function App() {
  return (
    <div className="flex flex-col items-center justify-center w-screen h-screen bg-indigo-400 text-6xl font-bold text-white">
      <p>Welcome 👋</p>
      <br />
      <Counter />
    </div>
  )
}
```

创建`Counter.jsx`

```jsx
import {useState} from 'react'

export default function Counter() {
  const [counter, setCounter] = useState(0)
  const increase = () => setCounter((count) => count + 1)
  const decrease = () => setCounter((count) => count - 1)
  return (
    <div>
      <button onClick={decrease}>-</button>
      <span className="px-4">{counter}</span>
      <button onClick={increase}>+</button>
    </div>
  )
}
```

构建后，现在的 Popup 插件展示如下：

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

emm，宽度不够，修改`style.css`

```css
#app {
  width: 350px;
}
```

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

## Source Code

[【Source Code】](https://github.com/rebelchris/popup-extension)


Chrome插件开发 - Popup extension


## 抽奖类型

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

### 圆形抽奖

代码如下：

```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为回调函数
}
```

待续
