使用泛型，您可以定义一组通用的操作，而不必在每种数据类型上编写单独的函数或方法。这使得代码更加灵活、可读性更高、易于维护，并提高了代码的重用性。

Swift - 泛型


结构体和类是 Swift 中两种重要的数据类型，它们都可以用于定义自定义的复合数据类型。结构体和类非常相似，但它们也有一些重要的区别。

结构体是一种值类型，它是由一些属性组成的。可以将结构体视为包含数据和相关方法的容器。结构体的实例在传递时被复制，而不是被引用。以下是一个简单的结构体示例：

```swift
struct Point {
var x: Int
var y: Int

    func moveX(by deltaX: Int) {
        x += deltaX
    }

    func moveY(by deltaY: Int) {
        y += deltaY
    }
}

var point = Point(x: 10, y: 20)
point.moveX(by: 5)
point.moveY(by: -10)
```

在上面的示例中，Point 是一个结构体类型，它包含了两个 Int 类型的属性，x 和 y。结构体还定义了两个方法，moveX(by:) 和 moveY(by:)，用于移动点的 x 和 y 坐标。point 是一个变量，它的类型是 Point，它被初始化为一个具有 x 坐标为 10，y 坐标为 20 的点。然后，它被移动了 5 个单位的 x 坐标和 10 个单位的 y 坐标。

类是一种引用类型，它也是由一些属性和方法组成的。类的实例是通过引用传递的，而不是通过复制。以下是一个简单的类示例：

```swift
class Person {
var name: String
var age: Int

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

    func celebrateBirthday() {
        age += 1
        print("Happy \(age)th birthday, \(name)!")
    }
}

var person = Person(name: "Alice", age: 30)
person.celebrateBirthday()
```

在上面的示例中，Person 是一个类类型，它包含了两个属性，name 和 age。类还定义了一个方法，celebrateBirthday()，用于增加年龄并输出生日祝福。person 是一个变量，它的类型是 Person，它被初始化为一个具有名字为 "Alice"，年龄为 30 的人。然后，它被庆祝了一次生日。

Swift 中的结构体和类都可以有属性和方法，它们也都支持继承和协议。结构体通常用于表示简单的数据结构，而类通常用于表示更复杂的对象。在编写代码时，应该根据需要选择结构体或类，以便在代码中使用正确的数据类型。


结构体和类是 Swift 中两种重要的数据类型，它们都可以用于定义自定义的复合数据类型。结构体和类非常相似，但它们也有一些重要的区别。

Swift - 结构体和类


React components 由一组元素构成。

基本函数组件的编写方式与常规 `JavaScript` 函数类似，但有几个不同之处。

- 组件名称必须以大写字母开头（即 MyComponent，而不是 myComponent）。
- 与 `JavaScript` 函数不同，组件必须返回 JSX。

以下是 `React` 函数组件的基本语法：

```jsx
function App() {
  return <div>Hello world!</div>
}
```


React是一个JavaScript库，致力于使UI开发变得简单

React Components


这篇文章将解释如何修改活动页面上的图片

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

修改`src/App.jsx`

```jsx
import React from 'react'

export default function ChangeImages() {
  // 获取活动页面所有图片
  const spoofImages = () => {
    const images = document.getElementsByTagName('img')
    for (const image of images) {
      image.removeAttribute('srcset') //去掉srcset，使srcset高质量图片失效
      image.src = 'http://placekitten.com/300'
    }
  }
  // 通过chrome钩子替换活动页面所有图片
  const imageSpoof = async () => {
    const [tab] = await chrome.tabs.query({active: true, currentWindow: true})
    chrome.scripting.executeScript({
      target: {tabId: tab.id},
      function: spoofImages
    })
  }
  return <button onClick={imageSpoof}>Change images</button>
}
```

## Source Code

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


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

Chrome插件开发 - Modify images on the page


Swift 有三种循环：

- for
- while
- repeat

## for 循环

> 用来重复执行一系列语句直到达成特定条件，如下图：

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

```swift
// 语法
for init; condition; increment{
   // do something
}

// example
let albums = ["Red", "1989", "Reputation"]
for album in albums {
    print("\(album) is on Apple Music")
}
```

## while 循环

> while 循环从计算单一条件开始。如果条件为 true，会重复运行一系列语句，直到条件变为 false。

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

```swift
// 语法
while condition{
   // do something
}
// example
var number = 1

while number <= 20 {
    print(number)
    number += 1
}

print("Ready or not, here I come!")
```

## repeat 循环

> repeat...while 循环不像 for 和 while 循环在循环体开始执行前先判断条件语句，而是在循环执行结束时判断条件是否符合。 `repeat...while无论条件是否符合，循环会执行至少一次`

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

```swift
// 语法
repeat{
   statement(s);
}while( condition );

// example
var number = 1

repeat {
    print(number)
    number += 1
} while number <= 20

print("Ready or not, here I come!")
```

## 退出循环

使用`break`退出循环语句，比如在 while 循环中：

```swift
while countDown >= 0 {
    print(countDown)

    if countDown == 4 {
        print("I'm bored. Let's go now!")
		// 当countDown等于4的时候会退出循环
        break
    }

    countDown -= 1
}
```

## 退出多重循环

在嵌套循环中，想要同时打破内循环和外循环是很常见的。举个例子，我们可以编写一些代码来计算从 1 到 10 的乘法表，如下所示:

```swift
for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")
    }
}
```

如果需要退出这个双重循环，需要做两步，首先，给外循环加上 label:`outerLoop`

```swift
outerLoop: for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")
    }
}
```

第二步，在内循环执行`break outerLoop`

```swift
outerLoop: for i in 1...10 {
    for j in 1...10 {
        let product = i * j
        print ("\(i) * \(j) is \(product)")

        if product == 50 {
            print("It's a bullseye!")
            break outerLoop
        }
    }
}
```

## 跳过条件 - continue

> `break`退出循环。但是，如果只想跳过当前条件，继续下一个条件，应该使用`continue`。比如如下跳过奇数：

```swift
for i in 1...10 {
    if i % 2 == 1 {
        continue
    }

    print(i)
}
```


Looping - 循环


## 布尔值

布尔值包括 `true` 和 `false`。

```go
var b bool = true
fmt.Printf("b is: '%v'\n", b)
//b = false
fmt.Printf("b is: '%v'\n", b)
var b2 bool
fmt.Printf("zero value of bool is: '%v'\n", b2)
//b is: 'true'
//b is: 'false'
//zero value of bool is: 'false'
```

布尔值的大小是 1 字节

```go
b := true
fmt.Printf("size of bool is: %d\n", unsafe.Sizeof(b))
//size of bool is: 1
```

## 整型

Go 语言支持的整数类型有 `int`、`uint`、`int8`、`uint8`、`int16`、`uint16`、`int32`、`uint32`、`int64`、`uint64`。

## 浮点型

Go 语言支持的浮点数类型有 `float32`、`float64`。

## 字符型

Go 语言支持的字符型 `byte`、`rune`，`byte`是一个字节，`rune`是一个代表一个字符的整数。

## 字符串

Go 中的 String 是一个不变的字节序列(8 位字节值) ，这与 Python、 c # 、 Java 或 Swift 等语言中的 Unicode 字符串不同。字符串类型的零值为空字符串。

```go
var s string // empty string ""
	s1 := "string\nliteral\nwith\tescape characters\n"
	s2 := `raw string literal
which doesnt't recgonize escape characters like \n
`
	fmt.Printf("sum of strings\n'%s'\n", s+s1+s2)
sum of strings
'string
literal
with	escape characters
raw string literal
which doesnt‘t recgonize escape characters like'
```

## 常量

Go 支持字符、字符串、布尔值和数值的常量。

```go
const (
	i  int = 32       // int constant
	s      = "string" // string constant
	i2     = 33       // untyped number constant
)

var (
	// values that are not read-only (like slices or maps or structs) cannot be
	// constants
	// we can declare them as top-level variables
	b = []byte{3, 4} // this could not be a constant
)
```


Basic Types


在 Swift 中，初始化(Initialization)是为类、结构体或枚举类型中的属性设置初始值的过程。初始化程序通常在创建一个新实例时调用，以确保该实例的所有属性都具有合适的初始值。

在 Swift 中，每个类、结构体或枚举类型都必须有至少一个初始化程序。如果没有显式地定义初始化程序，则 Swift 会提供一个默认的初始化程序。默认初始化程序假定所有属性都具有默认值，因此它不执行任何其他操作。

可以使用 init() 关键字定义初始化程序。例如：

```swift
class Person {
var name: String
var age: Int

    init() {
        name = "Unknown"
        age = 0
    }
}

let person = Person()
print(person.name) // 输出 "Unknown"
print(person.age) // 输出 0
```

在上面的示例中，我们定义了一个 Person 类，并在其中定义了一个 init() 初始化程序。该初始化程序将 name 和 age 属性设置为默认值。然后，我们创建一个新的 Person 实例，并输出其属性值。

在 Swift 中，初始化程序可以有参数，以便在创建实例时提供属性的初始值。例如：

```swift
class Person {
var name: String
var age: Int

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

let person = Person(name: "John", age: 30)
print(person.name) // 输出 "John"
print(person.age) // 输出 30
```

在上面的示例中，我们在 Person 类中定义了一个带有参数的初始化程序。该初始化程序使用提供的参数设置 name 和 age 属性。然后，我们创建一个新的 Person 实例，并输出其属性值。

在 Swift 中，初始化程序还可以调用其他初始化程序，以确保所有属性都被正确初始化。这种调用称为初始化程序委托(Initialization Delegation)。例如：

```swift
class Person {
var name: String
var age: Int

    init() {
        self.name = "Unknown"
        self.age = 0
    }

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

class Employee: Person {
var salary: Double

    init(name: String, age: Int, salary: Double) {
        self.salary = salary
        super.init(name: name, age: age)
    }
}

let employee = Employee(name: "John", age: 30, salary: 50000)
print(employee.name) // 输出 "John"
print(employee.age) // 输出 30
print(employee.salary) // 输出 50000.0
```

在上面的示例中，我们定义了一个 Employee 类，它是 Person 类的子类。Employee 类具有一个额外的 salary 属性。在 Employee 的 init() 初始化程序中，我们通过调用 super.init(name: age:) 委托给 Person 类的初始化程序来设置 name 和 age 属性。然后，我们设置 salary 属性并创建一个新的 Employee 实例。

初始化是 Swift 语言中非常重要的概念之一。通过初始化程序，我们可以确保实例的所有属性都具有


在 Swift 中，初始化(Initialization)是为类、结构体或枚举类型中的属性设置初始值的过程。