原型和原型链


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型。它返回左表中的所有行和右表中的所有行，包括在 ON 子句中不匹配的行。FULL OUTER JOIN 在想要在最终结果集中包含两个表中不匹配的行时非常有用。

以下查询使用`INNER JOIN`表连接到自身的查询

```sql
SELECT select_list
FROM table_name t1
INNER JOIN table_name t2 ON join_predicate;
```

此外还可以使用`LEFT JOIN`或`RIGHT JOIN`将表连接到自身：

```sql
SELECT select_list
FROM table_name t1
LEFT JOIN table_name t2 ON join_predicate;
```

## 示例

### 查询分层数据

假设有以下组织结构

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

创建`employee`表并将一些数据插入表中

```sql
CREATE TABLE employee (
	employee_id INT PRIMARY KEY,
	first_name VARCHAR (255) NOT NULL,
	last_name VARCHAR (255) NOT NULL,
	manager_id INT,
	FOREIGN KEY (manager_id)
	REFERENCES employee (employee_id)
	ON DELETE CASCADE
);
INSERT INTO employee (
	employee_id,
	first_name,
	last_name,
	manager_id
)
VALUES
	(1, 'Windy', 'Hays', NULL),
	(2, 'Ava', 'Christensen', 1),
	(3, 'Hassan', 'Conner', 1),
	(4, 'Anna', 'Reeves', 2),
	(5, 'Sau', 'Norman', 2),
	(6, 'Kelsie', 'Hays', 3),
	(7, 'Tory', 'Goff', 3),
	(8, 'Salley', 'Lester', 3);
```

使用自连接查询谁向谁报告

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
INNER JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

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

以上查询两次引用`employee`表，一次作为雇员，另一次作为经理，通过匹配`employee_id`和`manager_id`查找雇员/经理对

使用`LEFT JOIN`instead of`INNER JOIN`查询结果集中包含最高管理者

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
LEFT JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

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

### 比较同表的行

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

查询所有长度相同的电影

```sql
SELECT
    f1.title,
    f2.title,
    f1.length
FROM
    film f1
INNER JOIN film f2
    ON f1.film_id <> f2.film_id AND
       f1.length = f2.length;
```

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


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型

Postgresql - FULL OUTER JOIN


Automatic Reference Counting（ARC）是一种内存管理机制，它是由苹果公司在其 Objective-C 和 Swift 语言中使用的。ARC 的作用是在程序运行时自动管理对象的内存，从而避免了手动管理内存的繁琐和容易出错的问题。

在 Objective-C 中，ARC 是默认开启的，它通过计算对象的引用计数来自动管理对象的内存。每当一个对象被创建时，它的引用计数会被初始化为 1，每当一个对象被引用时，它的引用计数会增加 1，每当一个对象不再被引用时，它的引用计数会减少 1。当一个对象的引用计数为 0 时，它就会被自动释放掉。

在 Swift 中，ARC 同样是默认开启的，它采用了和 Objective-C 相同的引用计数机制。不同的是，在 Swift 中，我们可以使用强引用、弱引用和无主引用来管理对象的内存。强引用是最常见的引用类型，它会使对象的引用计数增加 1，并且只有在没有任何强引用指向对象时，对象的引用计数才会减少 1；弱引用和无主引用则可以用来避免循环引用的问题。

在使用 ARC 时，我们只需要遵循一些基本规则即可避免内存泄漏和野指针等问题。例如，我们可以使用 weak 或 unowned 来避免循环引用的问题；我们不应该手动管理内存，例如使用 retain、release 和 autorelease 等方法；我们需要避免在闭包中持有 self 等对象，以避免循环引用的问题等。

除了基本规则外，ARC 还提供了一些高级特性，例如自动闭包和无主引用等。下面我们来看一些常见的 ARC 特性。

## 自动闭包

自动闭包是一种方便的语法结构，它可以让我们把一个表达式封装成一个闭包，并在需要时自动调用它。在 Swift 中，我们可以使用 @autoclosure 关键字来声明一个自动闭包。例如：

```swift
func printIfTrue(_ predicate: @autoclosure () -> Bool) {
  if predicate() {
    print("True")
  } else {
    print("False")
  }
}

printIfTrue(2 + 2 == 4)
```

在上面的代码中，我们定义了一个 printIfTrue 函数，它接受一个返回 Bool 类型的自动闭包作为参数，并在需要时自动调用它。在调用该函数时，我们可以传递一个表达式，例如 2 + 2 == 4，这个表达式会被自动封装成一个闭包，并在 printIfTrue 函数中被调用。

## 无主引用

无主引用是一种特殊的弱引用，它用来避免弱引用在使用时被意外释放的问题。在 Swift 中，我们可以使用 unowned 关键字来声明一个无主引用。例如：

```swift
class Person {
  var name: String
  var apartment: Apartment?

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

    deinit {
        print("\(name) is being deinitialized")
    }
}

class Apartment {
  let number: Int
  weak var tenant: Person?

    init(number: Int) {
        self.number = number
    }

    deinit {
        print("Apartment #\(number) is being deinitialized")
    }
}

var john: Person?
var number73: Apartment?

john = Person(name: "John")
number73 = Apartment(number: 73)

john!.apartment = number73
number73!.tenant = john

john = nil
number73 = nil
```

在上面的代码中，我们定义了一个 Person 类和一个 Apartment 类，它们之间通过弱引用和无主引用进行关联。具体来说，Person 类中的 apartment 属性是一个可选的 Apartment 类型，并且它是通过弱引用来实现的；而 Apartment 类中的 tenant 属性是一个可选的 Person 类型，并且它是通过无主引用来实现的。这样，在我们释放 john 和 number73 变量所占用的内存时，它们之间的引用关系就可以正确地被解除。

总的来说，ARC 是一种非常方便和安全的内存管理机制，它可以自动管理对象的内存，从而避免了手动管理内存的繁琐和容易出错的问题。在使用 ARC 时，我们只需要遵循一些基本规则和高级特性即可，从而让我们更加专注于应用程序的业务逻辑。


ARC 的作用是在程序运行时自动管理对象的内存，从而避免了手动管理内存的繁琐和容易出错的问题。

Swift - ARC(内存管理机制)


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

![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插件开发 - 第一个插件


在这篇文章中将学习给浏览器添加通知推送事件，如下视频：

<video
  src="https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/notification_qlwotx.webm"
  autoPlay
/>

## 添加通知推送

[Browser notifications](https://web.dev/push-notifications-overview/)类似于手机上的消息通知。

添加权限

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

修改`src/App.jsx`

```jsx
export function App() {
  const createNotification = () => {
    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
    })
  }

  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}
      >
        Surprise me 🎉
      </button>
    </div>
  )
}
```

`chrome.notifications`创建浏览器通知

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

## Source Code

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


Chrome插件开发 - Adding browser notifications


Swift 有三种条件判断：

- if else
- switch
- ternary `三元运算`

### if else

> if 语句 后可以有可选的 else 语句, else 语句在布尔表达式为 false 时执行。

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

```swift
let level = 9001
if level > 9000 {
  print("It's over 9000! You can proceed with your quest.")
} else {
  print("Bummer, you definitely need to go for a training arc")
}
```

### switch

> switch 语句允许测试一个变量等于多个值时的情况。

```swift
let level = 10000

switch level {
   case 7000 :
     print("Muda Muda Muda Muda Muda Muda")
   case 8000 :
     print("You are not strong enough")
   case 9000 :
     print("You are strong enough! You can proceed with your quest")
   case 10000:
     print("It's over 9000! You can proceed with your quest.")
   default :
     print("Please try again")
}
```

### ternary

> switch 语句允许测试一个变量等于多个值时的情况。 Swift 语言中  只要匹配到 case 语句，则整个 switch 语句执行完成。

```swift
let level = 9000
print( level > 9000 ? "It's over 9000! You can proceed with your quest." :  print("Bummer, you definitely need to go for a training arc")
```


Operators and conditions - 操作符、条件判断


`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提供用来存放二进制数据的缓存区