Swift是一种适用于iOS、macOS、watchOS和tvOS应用程序的编程语言。

Swift - 创建和预览 SwiftUI 视图


在 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 支持继承，这是指在一个对象（称为“子类”）中继承另一个对象的属性和方法（称为“父类”）

继承


Next.js 允许使用 css-in-js 语法，并且支持 css-modules。比如`styled-jsx`、`css-modules`、`styled-components`等。

创建`container.module.css`

```css
.container {
  max-width: 960px;
  margin: 0 auto;
  padding: 0 20px;
  border: 1px solid #ddd;
}
```

在`component`目录下创建`container.jsx`并引入`container.module.css`

```jsx
import styles from './container.module.css'

function Container({children}) {
  return <div className={styles.container}>{children}</div>
}

export default Container
```

在`first.js`中引入`container.jsx`

```jsx
import Link from 'next/link'
import Head from 'next/head'
import Container from '../../components/container'

export default function FirstPost() {
  return (
    <>
      <Container>
        <Head>
          <title>My First Post</title>
        </Head>
        <h1>My First Post</h1>
        <h2>
          <Link href="/">
            <a>Home</a>
          </Link>
        </h2>
      </Container>
    </>
  )
}
```

启动服务

```bash
npm run dev
```

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


Next.js允许使用css-in-js语法，并且支持css-modules。

Next.js - CSS Support


SwiftUI 中的 List 视图是在可滚动视图中显示项目列表的强大工具。它通常用于以一种有组织的、易于阅读的方式表示数据。在这个食谱条目中，您将学习如何向 SwiftUI 应用程序添加 List 视图。

假设您想要构建一个简单的待办事项列表应用程序。下面是如何使用 List 视图显示任务列表的示例:

```swift
struct ContentView: View {
  let tasks = ["Task 1", "Task 2", "Task 3", "Task 4", "Task 5"]

  var body: some View {
    List(tasks, id: \.self) { task in
      Text(task)
    }
  }
}
```

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

在这个例子中，我们创建了一个名为 tasks 的字符串数组，然后将它传递给 List 视图。我们还使用 id 参数来告诉 SwiftUI 如何识别列表中的每个项目。在这种情况下，我们使用了 \.self，这意味着 SwiftUI 将使用每个项目的值来识别它们。最后，我们使用 Text 视图来显示列表中的每个项目。


Swift - 在 SwiftUI 中添加列表视图


在上一篇文章[【Spicing with react】](/blog/translate/build-chrome-extensions/spicing-with-react)学习了使用 react 创建新标签插件。

这篇文章替换掉 parcel，切换到 vite

删除`.parcel`

删除`package.json`内的`"parcel": "^2.7.0","parcel-reporter-static-files-copy": "^1.3.4",`

添加`vite`

```json
{
  "scripts": {
    "dev": "vite",
    "build": "vite build",
    "preview": "vite preview"
  },
  "dependencies": {
    "vite": "^3.0.4"
  },
  "devDependencies": {
    "@vitejs/plugin-react": "^2.0.0"
  }
}
```

重命名文件

- `App.js`=>`App.jsx`
- `Counter.js`=>`Counter.jsx`
- `index.js`=>`index.jsx`

将`index.jsx`移动到`src`

重命名`static`为`public`

由于没有使用`index.html`，所以要在`vite.config.js`特殊声明一下

```js
import {defineConfig} from 'vite'
import react from '@vitejs/plugin-react'

export default defineConfig({
  plugins: [react()],
  build: {
    rollupOptions: {
      input: {
        app: './new-tab.html'
      }
    }
  }
})
```

跑起来

```bash
npm run build
```

[【Source Code】](https://github.com/rebelchris/new-tab-extension/tree/vite)


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

Chrome插件开发 - Switch to vite


在 Swift 中，类型转换(Type Casting)指的是检查一个实例的类型，或将该实例视为其超类或子类之一的过程。

Swift 提供了两种类型转换方式：

- 通过类型检查来检查实例的类型是否与特定的类型相同（或是子类或父类）：使用 is 和 as 操作符来完成类型检查。

  - is 操作符用于检查一个实例是否属于某个特定类型或其子类。返回值为布尔类型。
  - as? 操作符用于尝试将实例转换为特定类型。如果转换成功，返回一个可选类型的实例，否则返回 nil。
  - as! 操作符强制将实例转换为特定类型。如果转换失败，会抛出一个运行时错误。

- 通过向下转换来将父类实例转换为其子类实例：使用 as? 或 as! 操作符完成向下转换。
  - as? 操作符尝试将父类实例转换为子类实例。如果转换成功，返回一个可选类型的子类实例，否则返回 nil。
  - as! 操作符强制将父类实例转换为子类实例。如果转换失败，会抛出一个运行时错误。

下面是一个示例代码：

```swift
class Animal {
  func makeSound() {
    print("I am an animal")
  }
}

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

let animal = Animal()
let dog = Dog()

// Type check
if dog is Animal {
  print("dog is an Animal")
}

// Downcasting
let maybeDog = animal as? Dog
if let dog = maybeDog {
  dog.makeSound()
} else {
  print("Not a dog")
}

// Forced downcasting
let definitelyDog = animal as! Dog // Runtime error!
```

在上面的代码中，我们创建了一个 Animal 类和一个继承自 Animal 的 Dog 类。使用 is 操作符检查 dog 实例是否是 Animal 类的子类，并使用 as? 操作符尝试将 Animal 实例转换为 Dog 实例。最后，使用 as! 操作符强制将 Animal 实例转换为 Dog 实例（如果尝试转换一个非 Dog 实例，则会引发运行时错误）


在Swift中，类型转换(Type Casting)指的是检查一个实例的类型，或将该实例视为其超类或子类之一的过程。。

Swift - 类型转换


SwiftUI 的一个重要特性是它如何与 Xcode 预览集成，这使您可以在处理用户界面时看到实时的用户界面代码。预览提供了一种快速有效的方法来开发和迭代应用程序的 UI 设计。

可以通过使用画布窗口中的控件或直接在 Xcode 编辑器中编辑代码来操作预览。在对代码进行更改时，预览将实时更新，使您能够看到这些更改如何影响 UI 的外观。

下面是一个如何在 SwiftUI 中使用预览的例子:

```swift
import SwiftUI

struct ContentView: View {
  var body: some View {
    VStack {
      Text("Hello, SwiftUI!")
        .padding()
      Button(action: {
        print("Button tapped!")
      }) {
        Text("Tap me!")
      }
    }
  }
}

struct ContentView_Previews: PreviewProvider {
  static var previews: some View {
    ContentView()
      .previewDevice("iPhone 14 Pro")
  }
}
```

在本例中，我们有一个简单的 `VStack`，它包含一个 `Text` 视图和一个 `Button` 视图。`ContentView_Previews` 结构负责生成实时预览。

当你在 `Xcode` 运行这个程序并显示预览时，你会看到你的用户界面显示在 `iPhone14 Pro` 上。然后，可以通过修改代码或使用预览窗口中的工具实时操作此视图。

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

除了在不同的设备上预览 UI 之外，你还可以设置不同的预览配置，比如明暗外观、方向、可访问性设置等等。例如，可以将 `ContentView_Previews` 替换为以下内容:

```swift
struct ContentView_Previews: PreviewProvider {
  static var previews: some View {
    ContentView()
      .previewDevice("iPhone 14 Pro")
    ContentView()
      .preferredColorScheme(.dark)
    ContentView()
      .previewInterfaceOrientation(.landscapeLeft)
  }
}
```

现在可以在你的画布上看到3个不同的预览: 一个是 iPhone 14 Pro，一个是 Dark Mode，还有一个是横向的:

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

使用预览是使用 SwiftUI 开发用户界面的一个强大工具。通过一点点的练习，你将能够快速而轻松地迭代你的设计，创建漂亮而响应迅速的应用程序。


SwiftUI 的一个重要特性是它如何与 Xcode 预览集成，这使您可以在处理用户界面时看到实时的用户界面代码。预览提供了一种快速有效的方法来开发和迭代应用程序的 UI 设计。