使用 Postgresql LIKE 检索查询是否类似于某个字符串。

Postgresql - LIKE


这篇文章学习创建一个插件用于改变每个页面的背景色

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

## 创建插件主体

浏览器插件的核心文件且必不可少的：manifest，它是个`json`文件，包含所有和插件相关的配置，必须放在根目录，其中`manifest_version`、`name`、`version`是必不可少的，`description`、`icons`是推荐的

以下是一些插件的配置项，供参考：

```json
{
  // 清单文件的版本，这个必须写，而且必须是2
  "manifest_version": 2,
  // 插件的名称
  "name": "demo",
  // 插件的版本
  "version": "1.0.0",
  // 插件描述
  "description": "简单的Chrome扩展demo",
  // 图标，一般偷懒全部用一个尺寸的也没问题
  "icons": {
    "16": "img/icon.png",
    "48": "img/icon.png",
    "128": "img/icon.png"
  },
  // 会一直常驻的后台JS或后台页面
  "background": {
    // 2种指定方式，如果指定JS，那么会自动生成一个背景页
    "page": "background.html"
    //"scripts": ["js/background.js"]
  },
  // 浏览器右上角图标设置，browser_action、page_action、app必须三选一
  "browser_action": {
    "default_icon": "img/icon.png",
    // 图标悬停时的标题，可选
    "default_title": "这是一个示例Chrome插件",
    "default_popup": "popup.html"
  },
  // 当某些特定页面打开才显示的图标
  /*"page_action":
 {
 "default_icon": "img/icon.png",
 "default_title": "我是pageAction",
 "default_popup": "popup.html"
 },*/
  // 需要直接注入页面的JS
  "content_scripts": [
    {
      //"matches": ["http://*/*", "https://*/*"],
      // "<all_urls>" 表示匹配所有地址
      "matches": ["<all_urls>"],
      // 多个JS按顺序注入
      "js": ["js/jquery-1.8.3.js", "js/content-script.js"],
      // JS的注入可以随便一点，但是CSS的注意就要千万小心了，因为一不小心就可能影响全局样式
      "css": ["css/custom.css"],
      // 代码注入的时间，可选值： "document_start", "document_end", or "document_idle"，最后一个表示页面空闲时，默认document_idle
      "run_at": "document_start"
    },
    // 这里仅仅是为了演示content-script可以配置多个规则
    {
      "matches": ["*://*/*.png", "*://*/*.jpg", "*://*/*.gif", "*://*/*.bmp"],
      "js": ["js/show-image-content-size.js"]
    }
  ],
  // 权限申请
  "permissions": [
    "contextMenus", // 右键菜单
    "tabs", // 标签
    "notifications", // 通知
    "webRequest", // web请求
    "webRequestBlocking",
    "storage", // 插件本地存储
    "http://*/*", // 可以通过executeScript或者insertCSS访问的网站
    "https://*/*" // 可以通过executeScript或者insertCSS访问的网站
  ],
  // 普通页面能够直接访问的插件资源列表，如果不设置是无法直接访问的
  "web_accessible_resources": ["js/inject.js"],
  // 插件主页，这个很重要，不要浪费了这个免费广告位
  "homepage_url": "https://www.baidu.com",
  // 覆盖浏览器默认页面
  "chrome_url_overrides": {
    // 覆盖浏览器默认的新标签页
    "newtab": "newtab.html"
  },
  // Chrome40以前的插件配置页写法
  "options_page": "options.html",
  // Chrome40以后的插件配置页写法，如果2个都写，新版Chrome只认后面这一个
  "options_ui": {
    "page": "options.html",
    // 添加一些默认的样式，推荐使用
    "chrome_style": true
  },
  // 向地址栏注册一个关键字以提供搜索建议，只能设置一个关键字
  "omnibox": {"keyword": "go"},
  // 默认语言
  "default_locale": "zh_CN",
  // devtools页面入口，注意只能指向一个HTML文件，不能是JS文件
  "devtools_page": "devtools.html"
}
```

现在让我们来创建插件的主体框架

1.创建目录

```bash
mkdir pinkify-extension && cd pinkify-extension
```

2.创建`manifest.json`

写入一些配置

```json
{
  "manifest_version": 3,
  "name": "Pinkify",
  "version": "1.0",
  "description": "Convert any page to a pinkish page 💖",
  "icons": {
    "48": "icons/pinkify-48.png"
  },
  "content_scripts": [
    {
      "matches": ["<all_urls>"],
      "js": ["pinkify.js"]
    }
  ]
}
```

3.创建`pinkify.js`

```
document.body.style.setProperty('background','#FDF2F7')
```

4.测试扩展

打开开发者工具，加载已解压的扩展程序，选择`pinkify-extension`目录即可。

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


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

Chrome插件开发 - 第一个插件


## 抽奖类型

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

### 圆形抽奖

代码如下：

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

待续


移动端抽奖


使用`WHERE`过滤`SELECT`返回行。

## 语法

```sql
SELECT select_list
FROM table_name
WHERE condition
ORDER BY sort_expression
```

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

**如果在语句中使用了列别名，就不能使用`WHERE`**

| Operator   | Description |
| ---------- | ----------- |
| =          | 等于        |
| `>`        | 大于        |
| `<`        | 小于        |
| `>=`       | 大于等于    |
| `<=`       | 小于等于    |
| `<>` or != | 不等于      |
| AND        | 逻辑与      |
| OR         | 逻辑或      |
| IN         | 包含        |
| BETWEEN    | 区间        |
| LIKE       | 相似匹配    |
| IS NULL    | 非空        |
| NOT        | 不是        |

## 示例

从示例数据库中查询

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

#### =

查询`first_name`等于`Jamie`

```sql
SELECT
	last_name,
	first_name
FROM
	customer
WHERE
	first_name = 'Jamie';
```

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

#### AND

查询`first_name`等于`Jamie`和`last_name`等于`Rice`

```sql
SELECT
	last_name,
	first_name
FROM
	customer
WHERE
	first_name = 'Jamie' AND
        last_name = 'Rice';
```

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

#### OR

查询`last_name`等于`Rodriguez`或`first_name`等于`Adam`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	last_name = 'Rodriguez' OR
	first_name = 'Adam';
```

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

#### IN

查询包含`Ann、Anne、Annie`任何一个

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name IN ('Ann','Anne','Annie');
```

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

#### LIKE

查询以`Ann`开头的`last_name`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name LIKE 'Ann%'
```

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

#### BETWEEN

查询`first_name`的长度大于等于 3 小于等于 5

```sql
SELECT
	first_name,
	LENGTH(first_name) name_length
FROM
	customer
WHERE
	first_name LIKE 'A%' AND
	LENGTH(first_name) BETWEEN 3 AND 5
ORDER BY
	name_length;
```

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

#### `<>`

查询`first_name`以`Bra`开头，而且`last_name`不等于`Motley`

```sql
SELECT
	first_name,
	last_name
FROM
	customer
WHERE
	first_name LIKE 'Bra%' AND
	last_name <> 'Motley';
```

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

`<>`和`!=`是相同的作用。


Postgresql - Where


## 创建类

`Class`和`Struct`类似，但是类可以继承其他类，并且类可以定义属性和方法。

```swift
class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}

#创建实例
let poppy = Dog(name: "Poppy", breed: "Poodle")
```

## 类继承

和`Struct`不同的是，`Class`可以继承其他类。

```swift
class Poodle: Dog {
    init(name: String) {
        super.init(name: name, breed: "Poodle")
    }
}

super.init(name: name, breed: "Poodle") // 调用父类的构造器
```

## 方法重写

类创建的实例可以重写父类的方法。

```swift
class Dog {
    func bark() {
        print("Woof!")
    }
}

let poppy = Dog()
poppy.bark()

# 类继承重写方法
class Poodle: Dog {
    override func bark() {
        print("Yip!")
    }
}
```

## final 类

`Swift`提供关键词`final`来防止类被继承。

```swift
fina class Dog {
    func bark() {
        print("Woof!")
    }
}
```

## 复制 objects

与`Struct`不同的是，`Class`可以被复制。

```swift
class Dog {
    var name: String
    var breed: String

    init(name: String, breed: String) {
        self.name = name
        self.breed = breed
    }

    func bark() {
        print("Woof!")
    }
}
var poppy = Dog(name: "Poppy", breed: "Poodle")
var poppyCopy = poppy
poppyCopy.name = "Poppy Copy"
```

## 反初始化

与`Struct`不同的是，`Class`可以被反初始化。

```swift
class Person {
    var name: String

    init(name: String) {
        self.name = name
    }

    func sayHello() {
        print("Hello, \(name)!")
    }
}
```

在循环中创建实例，可以使用`deinit`来定义反初始化方法。

```swift
for _ in 1...10 {
    let person = Person(name: "John")
    person.sayHello()
}

deinit {
    print("Goodbye, \(name)!")
}
```

## 可变性

类与结构在常量的处理方式上有所不同。如果一个类或结构体的实例被声明为常量，则该实例的所有属性也必须是常量。

```swift
class Person {
    var name = "Taylor Swift"
}
let person = Person()
person.name = "Justin Bieber"
print(person.name) // Justin Bieber

# 如果将类或结构体实例设置为常量，则不能修改实例的属性。
class Person {
    let name = "Taylor Swift"
}
```

## 总结

- `Class`和`Struct`是相似的，都可以使用属性和方法创建。
- 类可以继承其他类，并获得父类的所有属性和方法。
- 使用`final`来防止类被继承。
- 可以重写父类的方法。
- 当不同变量指向同一个类实例，它们指向的是同一块内存，改变一个会改变另一个
- 可以被反初始化。
- 类的属性可以被声明为可变的，但是不能被声明为常量。


Swift 类是构建代码所用的一种通用且灵活的构造体。

Classes - 类


在 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 - 下标


Postgresql join 用于连接两个或多个表的数据。下图是所有的 join 类型级语法

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

使用方式包括 inner join、left join、right join、full outer join。

首先创建两个表：

```sql
CREATE TABLE basket_a (
    a INT PRIMARY KEY,
    fruit_a VARCHAR (100) NOT NULL
);

CREATE TABLE basket_b (
    b INT PRIMARY KEY,
    fruit_b VARCHAR (100) NOT NULL
);

INSERT INTO basket_a (a, fruit_a)
VALUES
    (1, 'Apple'),
    (2, 'Orange'),
    (3, 'Banana'),
    (4, 'Cucumber');

INSERT INTO basket_b (b, fruit_b)
VALUES
    (1, 'Orange'),
    (2, 'Apple'),
    (3, 'Watermelon'),
    (4, 'Pear');
```

新建的表中有一些相同的数据，比如`apple`和`orange`

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

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

### 内连接

内连接检查第一个表 ( `basket_a`) 中的每一行。它将`fruit_a`列中的值 fruit_b 与第二个表 ( `basket_b`) 中每一行的列中的值进行比较。如果这些值相等，则内部连接会创建一个包含两个表中的列的新行，并将这个新行添加到结果集中。

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
INNER JOIN basket_b
    ON fruit_a = fruit_b;
```

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

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

### 左连接

使用左连接子句将`basket_a`表与`basket_b`表连接起来。在左连接上下文中，第一个表称为左表，第二个表称为右表。

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
LEFT JOIN basket_b
   ON fruit_a = fruit_b;
```

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

左连接开始从左表中选择数据。它将 fruit_a 列中的值与 basket_b 表中 fruit_b 列中的值进行比较。

如果这些值相等，则左连接会创建一个包含两个表的列的新行，并将此新行添加到结果集中。（参见结果集中的第 1 行和第 2 行）。

如果值不相等，左连接还会创建一个包含两个表中的列的新行，并将其添加到结果集中。但是，它 basket_b 用空值填充右表 ( ) 的列。（参见结果集中的第 3 行和第 4 行）。

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

要从左表中选择右表中没有匹配行的行，请使用带 WHERE 子句的左连接。例如：

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
LEFT JOIN basket_b
    ON fruit_a = fruit_b
WHERE b IS NULL;
```

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

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

### 右连接

右连接是左连接的反转版本。右连接开始从右表中选择数据。它将右表中每一行的 fruit_b 列中的每个值与 fruit_a 表中每一行的 fruit_a 列中的每个值进行比较。

如果这些值相等，则右连接会创建一个包含两个表中的列的新行。

如果这些值不相等，右连接还会创建一个包含两个表中的列的新行。但是，它用 NULL 填充左表中的列。

以下语句使用右连接将`basket_a`表与`basket_b`表连接起来：

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
RIGHT JOIN basket_b ON fruit_a = fruit_b;
```

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

### 全连接

完全外连接或完全连接返回一个结果集，其中包含左右表中的所有行，如果可用，则两边都有匹配的行。如果没有匹配，表的列将被填充为 NULL。

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
FULL OUTER JOIN basket_b
    ON fruit_a = fruit_b;
```

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

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

要返回一个表中没有匹配行的行，请使用带有`WHERE`如下子句的完全连接：

```sql
SELECT
    a,
    fruit_a,
    b,
    fruit_b
FROM
    basket_a
FULL JOIN basket_b
   ON fruit_a = fruit_b
WHERE a IS NULL OR b IS NULL;
```

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


Postgresql join包括inner join、left join、right join、full outer join。