JavaScript - Ultimate Free Resources


React Elements 使用 `HTML` 标签来构建组件。

```html
<h1>My Header</h1>
<p>My paragraph> <button>My button</button></p>
```

我们使用一个名为`JSX`的特性编写 React Elements。

然而，因为`JSX`实际上只是 JavaScript 函数（而不是 HTML），所以语法有点不同。

与 HTML 不同，单标记元素（如 img 元素）必须是自动关闭的。它们必须以正斜杠结尾`/`：

```jsx
<img src="my-image.png" />
<br />
<hr />
```


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

React Elements


泛型（Generics）是 Swift 中一项非常强大的功能，它允许您编写灵活、可重用的函数和类型，可以在任何数据类型上进行工作。

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

以下是一些基本概念：

## 泛型函数

泛型函数是可以在不同数据类型之间共享的函数。这些函数在调用时可以指定要使用的数据类型。在 Swift 中，泛型函数可以接受任何类型的参数，包括整数、浮点数、字符串和自定义类型。

下面是一个简单的泛型函数示例：

```swift
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
  let temp = a
  a = b
  b = temp
}
```

在这个例子中，我们定义了一个函数 swapTwoValues，它接受两个参数 a 和 b，它们都是泛型类型 T。函数体内使用了一个临时变量 temp，来交换 a 和 b 的值。

这个函数中的 \<T> 声明了一个类型参数 T，用来指定函数参数的类型。调用函数时，可以将具体的数据类型作为参数传入：

```swift
var a = 10
var b = 20
swapTwoValues(&a, &b) // a is now 20, and b is now 10
```

在这个示例中，我们将 a 和 b 作为参数传递给 swapTwoValues 函数，并通过引用传递（使用 & 符号）将它们作为可变参数传递。函数交换了 a 和 b 的值，所以现在 a 的值为 20，b 的值为 10。

## 泛型类型

泛型类型是可以用于多个不同类型的类型。使用泛型类型，可以编写通用代码，而不必为每个特定类型编写单独的代码。在 Swift 中，可以使用类、结构体和枚举来定义泛型类型。

下面是一个简单的泛型结构体示例：

```swift
struct Stack<Element> {
var items = [Element]()

    mutating func push(_ item: Element) {
        items.append(item)
    }

    mutating func pop() -> Element? {
        return items.popLast()
    }
}
```

在这个例子中，我们定义了一个泛型结构体 Stack，它可以用于存储任意类型的元素。该结构体包含一个数组 items，用于存储元素。结构体还包含两个方法，用于将元素添加到堆栈中和从堆栈中删除元素。

可以在创建 Stack 实例时，使用类型参数 `Element

当我们编写代码时，我们经常需要同时处理多个不同类型的值，这些类型的值可能会在未来的某个时候发生变化。使用泛型可以让我们编写出灵活的代码，可以在编译时进行类型检查，同时可以在运行时自动适应类型。

Swift 中的泛型允许我们定义通用类型和函数，可以适用于各种数据类型。这使我们可以写出更加通用和重用的代码。

在 Swift 中，我们可以通过在类型、函数或方法名称后面使用尖括号（\<>）和一个或多个占位符来声明泛型。这些占位符可以用于指定类型参数，这些参数在调用函数或实例化类型时将被替换为实际类型。

以下是一个使用泛型的示例：

```swift
func swapValues<T>(_ a: inout T, _ b: inout T) {
  let temp = a
  a = b
  b = temp
}

var x = 10
var y = 20

swapValues(&x, &y) // x is now 20, y is now 10
```

在这个例子中，我们定义了一个函数 swapValues，它使用了一个类型参数 T。在函数体内，我们声明了一个名为 temp 的临时变量，然后交换了 a 和 b 的值。由于 a 和 b 都是 inout 参数，因此它们将被修改为新的值。

我们可以使用这个函数来交换任何两个相同类型的值，例如整数、浮点数、字符串、数组等等。在调用这个函数时，我们需要提供两个相同类型的值作为参数。

泛型在 Swift 中是非常强大和灵活的，它们可以帮助我们写出高效、可维护和可重用的代码。


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

Swift - 泛型


协议（Protocol）是 Swift 中一种重要的类型，它描述了一种方法或者属性的集合。协议可以被任意类型实现，包括类、结构体、枚举和其他协议，从而让这些类型可以拥有相同的行为和接口。

协议定义了一些方法和属性，但不提供任何实现。实现协议的类型，必须遵循协议的要求并提供这些方法和属性的实际实现。

协议的语法如下：

```swift

protocol SomeProtocol {
// 协议定义
}
```

接下来，我们将了解协议的常见用法和特性。

## 协议的属性要求

协议可以要求实现者提供特定名字和类型的实例属性或类型属性。协议不指定属性是存储属性还是计算属性，只指定属性的名称和类型。此外，协议还要求属性是可读写的或只读的。

实现协议的类型，必须遵循协议的要求并提供这些属性的实际实现。如果协议要求实现的属性是可读写的，那么实现者必须提供一个可读写的属性实现；如果协议要求实现的属性是只读的，那么实现者可以提供一个可读的属性实现或一个只读的计算属性实现。

下面是一个协议属性要求的例子：

```swift

protocol Person {
var name: String { get set }
var age: Int { get }
}
```

这个协议定义了两个属性要求，name 和 age。name 是一个可读写的字符串类型的实例属性，age 是一个只读的整数类型的实例属性。

接下来，我们定义一个结构体 Student 来实现 Person 协议：

```swift

struct Student: Person {
var name: String
var age: Int
}
```

Student 结构体实现了 Person 协议，并提供了 name 和 age 属性的实现。由于 Person 协议要求 name 是可读写的，因此 Student 结构体提供了一个可读写的 name 属性实现。而 Person 协议要求 age 是只读的，因此 Student 结构体提供了一个只读的 age 属性实现。

## 协议的方法要求

协议可以要求实现者提供特定名字和类型的实例方法和类型方法。实现协议的类型，必须遵循协议的要求并提供这些方法的实际实现。

和属性要求一样，协议中的方法要求只定义方法名、参数以及返回类型，但不提供具体的实现。实现者必须自行实现这些方法。

下面是一个协议方法要求的例子：

当一个类型符合一个协议时，我们称这个类型为遵循该协议。协议定义了一组要求，遵循该协议的类型必须满足这些要求。

在 Swift 中，协议可以用来实现多态。这意味着，我们可以使用一个遵循该协议的实例来代替任何符合该协议的类型的实例，从而使代码更加通用。

下面是一些常见的协议和它们的使用方法：

## CustomStringConvertible

该协议可以让我们自定义类型的字符串描述。当我们打印一个遵循 CustomStringConvertible 协议的类型时，它将返回一个字符串描述。这在调试和日志记录时非常有用。

下面是一个实现 CustomStringConvertible 协议的例子：

```swift

struct Person: CustomStringConvertible {
let name: String
let age: Int

    var description: String {
        return "\(name), \(age) years old"
    }
}

let person = Person(name: "Alice", age: 28)
print(person) // Output: Alice, 28 years old
```

## Equatable

该协议可以让我们比较两个实例是否相等。当我们需要比较两个对象时，遵循 Equatable 协议的类型会自动获得 == 运算符的实现。

下面是一个实现 Equatable 协议的例子：

```swift

struct Point: Equatable {
let x: Int
let y: Int
}

let point1 = Point(x: 1, y: 2)
let point2 = Point(x: 1, y: 2)

if point1 == point2 {
print("The two points are equal.")
} else {
print("The two points are not equal.")
}
```

## Hashable

该协议可以让我们将一个类型实例转换为一个唯一的哈希值。遵循 Hashable 协议的类型可以用作字典的键或集合的元素。

下面是一个实现 Hashable 协议的例子：

```swift

struct User: Hashable {
let id: Int
let name: String
}

let user1 = User(id: 1, name: "Alice")
let user2 = User(id: 2, name: "Bob")

var userDict = [user1: "Alice", user2: "Bob"]
print(userDict[user1]) // Output: Optional("Alice")
```

## Codable

该协议可以让我们将一个类型编码为 JSON 或解码 JSON。遵循 Codable 协议的类型可以通过编码和解码操作在 Swift 和其他语言之间进行转换。

下面是一个实现 Codable 协议的例子：

```swift

struct Person: Codable {
let name: String
let age: Int
}

let person = Person(name: "Alice", age: 28)

let encoder = JSONEncoder()
let data = try encoder.encode(person)

let decoder = JSONDecoder()
let decodedPerson = try decoder.decode(Person.self, from: data)

print(decodedPerson) // Output: Person(name: "Alice", age: 28)
```


协议可以被任意类型实现，包括类、结构体、枚举和其他协议，从而让这些类型可以拥有相同的行为和接口。

Swift - 协议


在上一篇文章，当创建新菜单的时候，可以加载当前位置的天气数据，这章将学习创建弹窗插件。

## 创建小工具

新建`src/Weather.jsx`

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

export default function Weather() {
  const [latLng, setLatLng] = useState({})
  const [data, setData] = useState(null)
  useEffect(() => {
    if (!latLng.lat && !latLng.long) {
      navigator.geolocation.getCurrentPosition(function (position) {
        setLatLng({
          lat: position.coords.latitude,
          long: position.coords.longitude
        })
      })
      return
    }
    if (!data) {
      fetch(
        `${import.meta.env.VITE_APP_API_URL}/weather/?lat=${latLng.lat}&lon=${
          latLng.long
        }&units=metric&APPID=${import.meta.env.VITE_APP_API_KEY}`
      )
        .then((res) => res.json())
        .then((result) => setData(result))
    }
  }, [latLng])

  return (
    <div>
      <h2>The weather today ☁️</h2>
      <br />
      {!data ? (
        <p>Loading...</p>
      ) : (
        <>
          <p>Weather for: {data.name}</p>
          <p>
            Temp: {data.main.temp}° ({data.weather[0].main})
          </p>
        </>
      )}
    </div>
  )
}
```

更改`App.jsx`

```jsx
import Weather from './Weather'

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">
      <Weather />
    </div>
  )
}
```

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

在弹窗点击右键，会显示开发者工具，提示未获取`地理位置`权限，在`manifest.json`中添加如下:

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

重新构建并加载即可。

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

## Source Code

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


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

Chrome插件开发 - Popup weather extension


V8 是由 Chromium 项目为 Google Chrome 网页浏览器开发的开源 JavaScript 引擎。它是用 C++语言编写的，并且是一个轻量级的引擎，可以在很小的内存中运行。现在，它用于很多项目，比如 Couchbase、MongoDB、Node.js，等等。

## Node.js - V8

Node.js V8 模块表示 V8 引擎的实例，可以通过 V8.createContext()方法创建一个上下文，然后通过 V8.runInContext()方法来执行 JavaScript 代码。

它提供`v8.getHeapStatistics`和`v8.getHeapSpaceStatistics`方法来获取堆空间的统计信息。

```js
const v8 = require('v8')
```

## getHeapStatistics

该方法返回关于堆的统计数据，比如堆的大小，堆的使用情况等。

```js
const v8 = require('v8')
console.log(v8.getHeapStatistics())
// {
//   total_heap_size: 8589934592,
//   total_heap_size_executable: 0,
//   total_physical_size: 8589934592,
//   total_available_size: 8589934592,
//   used_heap_size: 8589934592,
//   heap_size_limit: 8589934592,
//   malloced_memory: 0,
//   peak_malloced_memory: 0,
//   does_zap_garbage: 0
// }
```

## getHeapSpaceStatistics

该方法返回关于堆空间的统计信息，比如堆空间的大小，堆空间的使用情况等。

```js
const v8 = require('v8')
console.log(v8.getHeapSpaceStatistics())
// [
//   {
//     space_name: 'new_space',
//     space_size: 8589934592,
//     space_used_size: 0,
//     space_available_size: 8589934592,
//     physical_space_size: 8589934592
//   },
//   {
//     space_name: 'old_space',
//     space_size: 8589934592,
//     space_used_size: 0,
//     space_available_size: 8589934592,
//     physical_space_size: 8589934592
//   },
//   {
//     space_name: 'code_space',
//     space_size: 8589934592,
//     space_used_size: 0,
//     space_available_size: 8589934592,
//     physical_space_size: 8589934592
//   },
//   {
//     space_name: 'map_space',
//     space_size: 8589934592,
//     space_used_size: 0,
//     space_available_size: 8589934592,
//     physical_space_size: 8589934592
//   },
//   {
//     space_name: 'large_object_space',
//     space_size: 8589934592,
//     space_used_size: 0,
//     space_available_size: 8589934592,
//     physical_space_size: 8589934592
//   },
//   ]
```

## V8 内存管理

目前，默认情况下，v8 在 32 位系统上的内存限制为 2GB，在 64 位系统上的内存限制为 4GB。


V8是由Chromium项目为Google Chrome网页浏览器开发的开源JavaScript引擎

Node.js - V8


> 可选字符串可能包含像“Hello”这样的字符串，或者它们可能是 `nil`——什么都没有。

## 处理缺失数据 - handling missing data

当不知道数据是否存在时，可以使用可选类型来处理。

```swift
var age: Int? = nil

age = 38
```

当需要使用类型的方法又不知道变量是否存在值的时候，可以使用`if let`或者`guard let`来处理。

`unwrapped`可以让你确保变量有值，如果没有值，程序会崩溃。

```swift
var name: String? = nil

if let unwrapped = name {
    print("\(unwrapped.count) letters")
} else {
    print("name is nil")
}

guard let unwrapped = name else {
    print("name is nil")
    return
}
```

## 强制转换和隐式转换

只有确认变量有值时，才可以使用`!`强制转换。

```swift
let str = "5"
let num = Int(str) // 这是不安全的，因为str可能不是一个整数

let num = Int(str)! // 这是安全的，因为str一定有值
```

隐式转换

```swift
let age: Int! = nil
```

## 合并可选值

当程序需要两个可选值时，可以使用`??`运算符来合并可选值。

```swift
func username(for id: Int) -> String? {
    if id == 1 {
        return "Taylor Swift"
    } else {
        return nil
    }
}

let user = username(for: 15) ?? "Anonymous"
```

## 可选链

通过可选链可避免多层嵌套的可选值获取错误。

```swift
let names = ["John", "Paul", "George", "Ringo"]

let beatle = names.first?.uppercased()
```

## 异常处理

当程序抛出异常时，可以使用`try`和`catch`来处理异常。比如下面的代码

```swift
enum PasswordError: Error {
    case obvious
}

func checkPassword(_ password: String) throws -> Bool {
    if password == "password" {
        throw PasswordError.obvious
    }

    return true
}

do {
    try checkPassword("password")
    print("That password is good!")
} catch {
    print("You can't use that password.")
}
```

还有一种方式是使用`try?`来尝试调用方法，如果方法抛出异常，则返回`nil`。

```swift
if let result = try? checkPassword("password") {
    print("Result was \(result)")
} else {
    print("Password is incorrect.")
}
```

另外一种方式是使用`try!`来强制调用方法，如果方法抛出异常，则程序会崩溃。

```swift
try! checkPassword("sekrit")
print("That password is good!")
```

## 类型转换

`Swift`提供了两种类型转换：`as`和`as?`。

```swift
class Animal { }
class Fish: Animal { }

class Dog: Animal {
    func makeNoise() {
        print("Woof!")
    }
}

let pets = [Fish(), Dog(), Fish(), Dog()]
```

使用`as?`来检查类型转换是否成功。如果类型转换成功，则返回一个可选值，否则返回`nil`。

```swift
for pet in pets {
  if let dog = pet as? Dog{
    dog.makeNoise()
  }
}
```


可选是一个枚举类型，它可以是一个值或者空。类似于js的optional chaining