什么是容器


在Go语言中，接口（Interface）是一种类型，它定义了一组方法的契约。接口定义了方法的集合，而不关心方法的具体实现。接口提供了一种抽象的方式来描述对象的行为。

Go中的接口由一组方法签名组成，方法签名定义了方法的名称、参数列表和返回值类型。一个类型只要实现了接口中定义的所有方法，就被认为是实现了该接口。通过这种方式，接口实现了多态的特性，即不同类型的对象可以以相同的接口类型进行处理。

## 接口定义

```go
type 接口类型名 interface{
    方法名1(参数列表1) 返回值列表1
    方法名2(参数列表2) 返回值列表2
    …
}
```

## 接口实现

```go
type 类型名 struct{
    //字段
}
//实现接口方法
func (变量名 类型名) 方法名1(参数列表1) 返回值列表1{
    //方法体
}
func (变量名 类型名) 方法名2(参数列表2) 返回值列表2{
    //方法体
}
```

接口的实现是隐式的，不需要显式声明。只要一个类型实现了接口中定义的所有方法，即可视为实现了该接口。例如：

```go
type Animal interface {
    Speak() string
}

type Dog struct {}

func (d Dog) Speak() string {
    return "Woof!"
}

func main() {
    var animal Animal
    animal = Dog{}
    fmt.Println(animal.Speak()) // 输出: "Woof!"
}
```

在上面的例子中，我们定义了一个 Animal 接口，只有一个 Speak 方法。然后，我们创建了一个 Dog 结构体，并为 Dog 类型实现了 Speak 方法。在 main 函数中，我们将 Dog 类型赋值给 Animal 类型的变量 animal，并调用了 Speak 方法。
接口的特点和用途包括：

- 多态性：接口允许在不同的类型之间实现多态。通过将对象视为接口类型，可以处理不同类型的对象，而无需关心其具体的类型。
- 松耦合：接口可以实现组件之间的松耦合，组件只需要关注接口定义的方法，而不需要关心具体的实现。
- 可插拔性：接口可以作为插件或模块的契约，允许将不同的实现替换为其他实现，而不会影响使用该接口的其他代码。


Go Inteface是一种类型，一种抽象的类型。

Go - 接口


在 JavaScript 中，继承可以通过构造函数、原型链、实例、拷贝实现。

## 构造继承

构造继承是指创建一个新的对象，并将其父对象的属性和方法复制到新对象上，并对新对象进行初始化。

```js
// 定义父对象
function Person(name, age) {
  this.name = name
  this.age = age
}

Person.prototype.sayHello = function () {
  console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`)
}

// 定义子对象
function Student(name, age, major) {
  Person.call(this, name, age)
  this.major = major
}

// 继承父对象的方法
Student.prototype = Object.create(Person.prototype)
Student.prototype.constructor = Student

// 定义子对象自己的方法
Student.prototype.study = function () {
  console.log(`I am studying ${this.major}.`)
}

const john = new Student('John Doe', 22, 'Computer Science')
john.sayHello()
john.study()
```

在这个示例中，通过将父对象的方法复制到子对象的原型链上，实现了构造继承。

## 原型继承

原型继承通过将子对象的原型指向父对象来实现继承。以下是一个简单的原型继承的例子：

```js
function Parent(name) {
  this.name = name
}

Parent.prototype.sayName = function () {
  console.log('My name is ' + this.name)
}

function Child(name, age) {
  Parent.call(this, name)
  this.age = age
}

Child.prototype = Object.create(Parent.prototype)
Child.prototype.constructor = Child

Child.prototype.sayAge = function () {
  console.log('My age is ' + this.age)
}

var child = new Child('John', 25)
child.sayName() // My name is John
child.sayAge() // My age is 25
```

先定义了一个 Parent 函数，它有一个 name 属性和一个 sayName 方法。然后，我们定义了一个 Child 函数，该函数继承了 Parent 函数。我们在 Child 函数中通过调用 Parent.call(this, name) 来初始化 name 属性，并且在 Child.prototype 上添加了一个 sayAge 方法。最后，我们创建了一个 Child 的实例，可以使用继承过来的 sayName 方法和 sayAge 方法。

从 ECMAScript 6 开始，JavaScript 增加了 class 关键字，可以更方便地实现继承。

```js
class Parent {
  constructor(name) {
    this.name = name
  }

  sayName() {
    console.log(this.name)
  }
}

class Child extends Parent {
  constructor(name, age) {
    super(name)
    this.age = age
  }
}

var child = new Child('Tom', 20)
console.log(child.name) // Tom
console.log(child.age) // 20
child.sayName() // Tom
```

## 实例继承

原型链的实现原理是，每个对象都有一个指向它的构造函数的原型的指针，以及一个指向该对象的原型的指针，而原型对象又有自己的原型对象。通过这种方式，所有的对象都构成了一个原型链，我们可以通过在原型对象上定义属性和方法来让它们被所有对象继承。

例如，我们可以定义一个基础对象 Animal，并在其原型对象上定义一个 sayHello 方法：

```js
function Animal() {}
Animal.prototype.sayHello = function () {
  console.log('Hello, I am an animal.')
}
```

然后，我们可以定义一个继承 Animal 的对象 Dog：

```js
function Dog() {}
Dog.prototype = Object.create(Animal.prototype)
Dog.prototype.constructor = Dog
```

现在，我们可以创建一个 Dog 对象并调用 sayHello 方法：

```js
const dog = new Dog()
dog.sayHello() // 输出 "Hello, I am an animal."
```

由此可见，Dog 对象继承了 Animal 的 sayHello 方法。

## 拷⻉继承

拷贝继承是指通过复制一个对象的属性和方法到另一个对象中来实现继承。这种方法主要通过使用一个循环或工具函数，将父对象的属性复制到子对象中。但是，拷贝继承存在一些问题，例如无法在父对象中更改子对象的属性。因此，拷贝继承通常不是首选的继承方法。

以下是一个 JavaScript 拷贝继承的示例：

```js
function Parent(name) {
  this.name = name
}

Parent.prototype.sayName = function () {
  console.log(this.name)
}

function Child(name, age) {
  Parent.call(this, name)
  this.age = age
}

// 将父对象的属性和方法复制到子对象上
for (var prop in Parent.prototype) {
  Child.prototype[prop] = Parent.prototype[prop]
}

var child = new Child('John', 30)
child.sayName() // 输出 'John'
console.log(child.age) // 输出 30
```

在上面的示例中，我们通过循环将父对象的属性和方法复制到了子对象的原型上，从而实现了拷贝继承。

## 原型 prototype 机制或 apply 和 call ⽅法去实现较简单，建议使⽤构造函数与原型混合⽅式

```js
function Parent() {
  this.name = 'wang'
}
function Child() {
  this.age = 28
}
Child.prototype = new Parent() //继承了Parent，通过原型
var demo = new Child()
alert(demo.age)
alert(demo.name) //得到被继承的属性
```


JavaScript 支持继承，这是指在一个对象（称为“子类”）中继承另一个对象的属性和方法（称为“父类”）

继承


## 关于 404

[http status](https://manon.icu/http-status)
[404](https://www.abstractapi.com/http-status-codes/404)

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

## 自定义 404 页面

创建`404.js`文件，并在其中定义自定义 404 页面。

```js
import Link from 'next/link'

const MyCustom404Page = (props) => {
  return (
    <div
      style={{
        marginTop: 100,
        display: 'flex',
        flexDirection: 'column',
        justifyContent: 'center',
        alignItems: 'center'
      }}
    >
      <h1>404</h1>
      <h2>
        <Link href="/" style={{color: 'blue', textDecoration: 'underline'}}>
          Go To Home Page
        </Link>
      </h2>
      <p>Sorry, the content you are looking for cuould not be found.</p>
    </div>
  )
}

export default MyCustom404Page
```

检查结果

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

## 动态渲染 404 页面

next.js 允许通过`getStaticProps`或`getServerSideProps`请求数据并自定义 404 页面。

```js
import Link from 'next/link'

const MyCustom404Page = (props) => {
  return (
    <div
      style={{
        marginTop: 100,
        display: 'flex',
        flexDirection: 'column',
        justifyContent: 'center',
        alignItems: 'center'
      }}
    >
      <h1>404 - Page Not Found</h1>
      <h2>
        <Link href="/" style={{color: 'blue', textDecoration: 'underline'}}>
          Go To Home Page
        </Link>
      </h2>
      <p>Or check out our latest news:</p>
      <hr />
      <ul>
        {posts.map((articles) => (
          <li>{/* article title and href here */}</li>
        ))}
      </ul>
    </div>
  )
}

export async function getStaticProps() {
  // Call an external API endpoint to get posts.
  const res = await fetch('YOUR_API_URL')
  const posts = await res.json()

  return {
    props: {
      posts
    },
    // Next.js will attempt to re-generate the page:
    // - When a request comes in
    // - At most once every second
    revalidate: 60
  }
}

export default MyCustom404Page
```


Next.js - Custom 404


在上一篇文章[【Add Tailwind】](/blog/translate/build-chrome-extensions/add-tailwind)学习了集成 tailwind。

这篇文章学习使用 react 创建一个新标签插件，类似如图：

也可以使用其他自己喜欢的框架：vue、angular、svlete 等

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

## 安装 React

```bash
npm install react react-dom
touch -p index.js src/{App,Counter}.js
vim new-tab.html
```

**new-tab.html**

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

**index.js**

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

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

**App.js**

```js
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>
      <Counter />
    </div>
  )
}
```

**Counter.js**

```js
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>
  )
}
```

跑起来

```bash
npm run build
```

## 测试插件

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

可以在这里找到[【Source Code】](https://github.com/rebelchris/new-tab-extension/tree/react)


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

Chrome插件开发 - 使用React开发扩展


JavaScript 中的函数执行过程可以分为两个阶段：函数定义和函数调用。

## 函数定义阶段：

在 JavaScript 中，函数可以通过函数声明或函数表达式的方式进行定义。在函数定义阶段，JavaScript 解析器会扫描代码，将函数声明和函数表达式提升到作用域的顶部。这意味着函数可以在其定义之前被调用。
例如：

```javascript
foo() // 函数调用在函数定义之前

function foo() {
  console.log('Hello, world!')
}
```

在上述代码中，函数 foo 在被定义之前就被调用了，这是因为函数定义在代码执行之前被提升到了作用域的顶部。

## 函数调用阶段：

在函数调用阶段，JavaScript 解释器会执行函数体中的代码。当函数被调用时，会创建一个新的执行上下文（Execution Context），并且将该执行上下文推入执行上下文栈（Execution Context Stack）中。

执行上下文包含了函数的作用域、参数、变量以及函数内部的代码执行位置等信息。在函数执行过程中，JavaScript 解释器根据代码的执行顺序逐行执行函数内部的语句。

函数执行过程中涉及以下几个重要的步骤：

- 创建函数的作用域链：在函数执行前，JavaScript 解释器会创建一个作用域链，该链包含了函数自身作用域以及所有外部作用域。作用域链的顶部是全局作用域。
- 创建函数的活动对象（Activation Object）：活动对象是函数执行过程中的一个内部对象，用于存储函数的参数、局部变量和内部函数的引用。活动对象会被添加到作用域链的顶部，成为当前执行上下文的变量对象。
- 解析和执行函数的代码：JavaScript 解释器会逐行解析和执行函数体中的代码。在执行过程中，变量会根据作用域链进行查找和访问。
- 返回结果或继续执行：函数执行过程中可能会返回一个值，也可能不返回任何值。当函数执行完毕或遇到 return 语句时，会将结果返回给调用者，并将当前执行上下文从执行上下文栈中弹出，恢复到上一个执行上下文继续执行。

总结起来，JavaScript 中的函数执行包括函数定义阶段和函数调用阶段。在函数定义阶段，函数声明和函数表达式被提升到作用域的顶部。在函数调用阶段，创建执行上下文，建立作用域链和活动对象，执行函数体中的代码，最后返回结果或继续执行其他代码。理解函数的执行过程对于编写和调试 JavaScript 代码非常重要。


理解函数的执行过程


当输出数据时，我们希望能够按照一定的格式输出，这个时候就可以使用 format()函数。比如：

```python
      Name      Shares        Price
----------  ----------  -----------
        AA         100        32.20
       IBM          50        91.10
       CAT         150        83.44
      MSFT         200        51.23
        GE          95        40.37
      MSFT          50        65.10
       IBM         100        70.44
```

## 字符输出格式化

在`python 3.6+`使用`f-strings`格式化字符串，如下：

```python
name = 'IBM'
shares = 100
price = 91.1
f'{name:>10s} {shares:>10d} {price:>10.2f}'
#'       IBM        100      91.10'

# 通常配合 print()函数使用，如下：
print(f'{name:>10s} {shares:>10d} {price:>10.2f}')
```

## 格式化代码

格式代码(在`{}`中`:` 之后)类似于 c `printf ()`。常见代码包括:

```python
d       # 整数
b       # 十六进制
x       # 十六进制
f       # 浮点数
e       # 指数
g       # 指数或浮点数
s       # 字符串
c       # 字符
```

常用的修饰符调整字段宽度和十进制精度。这是一个部分列表:

```python
:>10d   # 宽度为10，十进制精度无限制
:<10d   # 宽度为10，十进制精度无限制
:^10d   # 宽度为10，十进制精度无限制
:0.2f   # 宽度为无限制，十进制精度为2
```

## 字典格式化

使用`format_map`函数可以将字典中的键和值对应输出，如下：

```python
s = {
    'name': 'IBM',
    'shares': 100,
    'price': 91.1
}
'{name:>10s} {shares:10d} {price:10.2f}'.format_map(s)
#'       IBM        100      91.10'
```

## format()函数

```python
'{name:>10s} {shares:10d} {price:10.2f}'.format(name='IBM', shares=100, price=91.1)
#'       IBM        100      91.10'
'{:10s} {:10d} {:10.2f}'.format('IBM', 100, 91.1)
#'       IBM        100      91.10'
```

## C 语言格式化

使用`%`可以格式化字符串，如下：

```python
'The value is %d' % 3
#'The value is 3'
'%5d %-5d %10d' % (3,4,5)
#'    3 4              5'
'%0.2f' % (3.1415926,)
#'3.14'
```
