文本视图是 SwiftUI 用户界面中最常用的元素之一。

Swift - 在 SwiftUI 中添加文本视图


Swift 中的函数可以完成特定的任务，并且可以重复使用。函数使代码的组织和抽象化更加容易，也使代码更易于维护和重构。

以下是 Swift 中定义和调用函数的示例：

```swift
// 定义一个函数
func greet(person: String) -> String {
  let greeting = "Hello, " + person + "!"
  return greeting
}

// 调用函数
let result = greet(person: "Tom")
print(result)
```

Swift 中的函数有以下特点：

- 可以有多个参数，每个参数都有一个名字和一个类型。
- 可以有返回值，返回值可以是任何类型，也可以没有返回值。
- 可以有默认参数，使函数的调用更加方便。
- 可以使用可变参数，使函数的参数数量变得不确定。
- 可以使用 inout 参数，使函数可以修改传入参数的值。
- 可以使用函数类型，使函数作为参数或返回值传递。
  以下是上述特点的示例：

```swift
// 默认参数
func greet(person: String, greeting: String = "Hello") -> String {
  let result = greeting + ", " + person + "!"
  return result
}

let result2 = greet(person: "Tom")
let result3 = greet(person: "Tom", greeting: "Hi")

// 可变参数
func sum(numbers: Int...) -> Int {
  var result = 0
  for number in numbers {
    result += number
  }
  return result
}

let result4 = sum(numbers: 1, 2, 3, 4)

// inout 参数
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
  let temp = a
  a = b
  b = temp
}

var a = 10
var b = 20
swapTwoInts(&a, &b)

// 函数类型
func add(_ a: Int, _ b: Int) -> Int {
  return a + b
}

func subtract(_ a: Int, _ b: Int) -> Int {
  return a - b
}

func operate(_ a: Int, _ b: Int, operation: (Int, Int) -> Int) -> Int {
  return operation(a, b)
}

let result5 = operate(10, 5, operation: add)
let result6 = operate(10, 5, operation: subtract)
```

Swift 中的函数是一种非常有用的工具，可以使代码更加简洁、可读和易于维护。在编写代码时，应该考虑将代码组织成函数，以提高代码的重用性和可维护性。


Swift 中的函数可以完成特定的任务，并且可以重复使用。函数使代码的组织和抽象化更加容易，也使代码更易于维护和重构。

Swift - 函数


到目前为止，使用 `Link` 组件从一个页面导航到另一个页面。使用 `Router` 组件也可以实现相同的功能。

更新`index.js`

```jsx
import Router from 'next/router'
import Head from 'next/head'

function HomePage(props) {
  return (
    <>
      <Head>
        <title>Welcome to Next.js!</title>
      </Head>
      <div>Welcome to Next.js!</div>
      <span onClick={() => Router.push('/posts/one')}>First Post</span>
      <br />
      <div>Next stars: {props.stars}</div>
      <img src="/logo.png" alt="Logo" />
    </>
  )
}

export async function getServerSideProps(context) {
  const res = await fetch('https://api.github.com/repos/vercel/next.js')
  const json = await res.json()
  return {
    props: {stars: json.stargazers_count}
  }
}

export default HomePage
```

启动服务

```bash
npm run dev
```

验证结果

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


Next.js - Imperative Routing


在 CSS 中，有多种不同的 sizing units（尺寸单位）可以用来定义元素的尺寸和位置，下面是一些常见的 sizing units：

- px（像素）：像素是 CSS 中最常用的尺寸单位之一，它指的是屏幕上的一个物理像素。因为像素是一个固定的尺寸，所以使用像素定义元素的大小可以确保它们在不同的设备上显示一致。
- %（百分比）：百分比单位是相对于父元素的大小来定义元素的尺寸。例如，如果一个元素的宽度设置为 50%，那么它的宽度将会是其父元素宽度的一半。
- em（字号）：em 是相对于元素的字体大小来定义尺寸的单位。例如，如果一个元素的字体大小为 16px，那么 1em 将等于 16px。
- rem（根字号）：rem 也是相对于字体大小来定义尺寸的单位，但是它是相对于根元素的字体大小来计算的。例如，如果根元素的字体大小为 16px，那么 1rem 将等于 16px。
- vw/vh（视窗宽度/高度）：vw 和 vh 是相对于视口宽度和高度来定义尺寸的单位。例如，如果一个元素的宽度设置为 50vw，那么它的宽度将会是视口宽度的一半。
- vmin/vmax（视口宽度/高度的较小或较大值）：vmin 和 vmax 也是相对于视口宽度和高度来定义尺寸的单位。vmin 指的是视口宽度和高度中较小的值，而 vmax 则指的是较大的值。

除了以上列举的 sizing units，CSS 还有一些其他的尺寸单位，如 pt（磅）、pc（派卡）等，但它们在网页设计中使用较少。需要注意的是，不同的 sizing units 适用于不同的场景，根据具体需求选择合适的尺寸单位来定义元素的尺寸和位置是非常重要的。

## 案例

以下是使用不同 sizing units 的 CSS 示例：

1. px（像素）

```css
div {
  width: 200px;
  height: 150px;
  font-size: 16px;
}
```

2. %（百分比）

```css
.parent {
  width: 500px;
  height: 300px;
}

.child {
  width: 50%;
  height: 50%;
}
```

3. em（字号）

```css
.parent {
  font-size: 16px;
}

.child {
  width: 10em;
  height: 5em;
}
```

4. rem（根字号）

```css
html {
  font-size: 16px;
}

.child {
  width: 20rem;
  height: 10rem;
}
```

5. vw/vh（视窗宽度/高度）

```css
.child {
  width: 50vw;
  height: 25vh;
}
```

6. vmin/vmax（视口宽度/高度的较小或较大值）

```css
.child {
  width: 50vmin;
  height: 50vmax;
}
```


css - 尺寸单位


Next.js 是基于 React 的框架，具有服务器端渲染功能。它非常快速，对搜索引擎优化友好

- Hot Code Reloading:Next.js 支持热更新，可以在源代码更改后立即生效。
- 自动路由:无需配置路由，Next.js 会自动生成路由。
- 组件化样式:Next.js 支持组件化样式，可以在组件中使用 styled-jsx 或者\*.module.scss 等。
- ssr:React 组件在服务器上预先渲染，因此在客户端加载速度更快。
- Node 生态
- 自动代码切割:Next.js 支持自动代码切割，只在需要用的时候才加载模块。
- Prefetch:Next.js 支持预加载，可以在页面加载时预加载页面。
- 动态组件:Next.js 支持动态引入模块或者组件。
- 导出静态站点:Next.js 支持导出静态站点，可以在服务器上构建静态页面。
- 内置 TS 支持:Next.js 由 TS 开发，支持 TS 语法。

[Next.js 官方文档](https://nextjs.org/docs)


Next.js是基于React的框架，具有服务器端渲染功能。

Next.js - Overview


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(内存管理机制)

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

## `loading=lazy`属性

> 这是一个性能优化的措施，图片懒加载

```html
<img src="image.jpg" loading="lazy" alt="Alternative Text" />
```

## Email、tel、sms

```html
<a href="mailto:{email}?subject={subject}&body={content}"> Send us an email </a>

<a href="tel:{phone}"> Call us </a>

<a href="sms:{phone}?body={content}"> Send us a message </a>
```

## 列表`start`属性

> 使用`start`属性改变列表的初始序号

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

## meter Element

> 无需 js、css 写出 progress bar

```html
<label for="value1">Low</label>
<meter
  id="value1"
  min="0"
  max="100"
  low="30"
  high="75"
  optimum="80"
  value="25"
></meter>

<label for="value2">Medium</label>
<meter
  id="value2"
  min="0"
  max="100"
  low="30"
  high="75"
  optimum="80"
  value="50"
></meter>

<label for="value3">High</label>
<meter
  id="value3"
  min="0"
  max="100"
  low="30"
  high="75"
  optimum="80"
  value="80"
></meter>
```

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

## html 原生搜索

```html
<div class="wrapper">
  <h1>Native HTML Search</h1>

  <input list="items" />

  <datalist id="items">
    <option value="Marko Denic"></option>
    <option value="FreeCodeCamp"></option>
    <option value="FreeCodeTools"></option>
    <option value="Web Development"></option>
    <option value="Web Developer"></option>
  </datalist>
</div>
```

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

## Fieldset Element

```html
<form>
  <fieldset>
    <legend>Choose your favorite language</legend>

    <input type="radio" id="javascript" name="language" />
    <label for="javascript">JavaScript</label><br />

    <input type="radio" id="python" name="language" />
    <label for="python">Python</label><br />

    <input type="radio" id="java" name="language" />
    <label for="java">Java</label>
  </fieldset>
</form>
```

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

## Window.opener

> 用`target = "_ blank"`打开的页面允许新页面访问原始页面的`window.opener`。这可能具有安全性和性能影响。包括`rel = "noopener"或者`rel = "noreferer"`来防止这种情况。

```html
<a href="https://markodenic.com/" target="_blank" rel="noopener">
  Marko's website
</a>
```

## Base Element

> 如果需要在新标签打开所有的链接，使用`base`

```html
<head>
  <base target="_blank" />
</head>

<div class="wrapper">
  This link will be opened in a new tab: &nbsp;
  <a href="https://freecodetools.org/"> Free Code Tools </a>

  <p>
    Read more: <br /><a
      href="https://developer.mozilla.org/en-US/docs/Web/HTML/Element/base"
    >
      MDN Documentation
    </a>
  </p>
</div>
```

## 去除 favicon 缓存

> 使用时间戳或者其他版本信息去除缓存，这样每次获取的 favicon 都是新的

```html
<link rel="icon" href="/favicon.ico?v=2" />
```

## 原生 sliders

```html
<label for="volume">Volume: </label>
<input type="range" id="volume" name="volume" min="0" max="20" />

<label for="result">Your choice: </label>
<input type="number" id="result" name="result" />
```

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

## html Accordion

```html
<div class="wrapper">
  <details>
    <summary>Click me to see more details</summary>

    <p>
      Lorem ipsum dolor sit amet consectetur adipisicing elit. Ut eum
      perferendis eius. Adipisci velit et similique earum quas illo odio rerum
      optio, quis, expedita assumenda enim dicta aliquam porro maxime minima sed
      a ullam, aspernatur corporis.
    </p>
  </details>
</div>
```

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

## mark 标签

> 使用`mark`标签高亮文字

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

## `download`属性

```html
<a href="path/to/file" download> Download </a>
```

## picture 标签

```html
<picture>
  
  <source srcset="logo.webp" type="image/webp" />

  
  <img src="logo.png" alt="logo" />
</picture>
```

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

## fancy text

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

```html
<h1>CSS IS AWESOME</h1>

<style>
  h1 {
    background: blue url('https://picsum.photos/id/1015/200/300');
    background-clip: text;
    -webkit-background-clip: text;
    color: transparent;
    margin-top: 20px;
    font-size: 120px;
  }
</style>
```

## caret-color

> 改变光标颜色

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

## CSS only tooltips

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

```html
<h1>HTML/CSS tooltip</h1>

<p>
  Hover <span class="tooltip" data-tooltip="Tooltip Content">Here</span> to see
  the tooltip.
</p>

<p>
  You can also hover
  <span class="tooltip" data-tooltip="This is another Tooltip Content"
    >here</span
  >
  to see another example.
</p>

<style>
  .tooltip {
    position: relative;
    border-bottom: 1px dotted black;
  }

  /* Tooltip box */
  .tooltip:before {
    content: attr(data-tooltip);
    position: absolute;
    width: 100px;
    background-color: #062b45;
    color: #fff;
    text-align: center;
    padding: 10px;
    line-height: 1.2;
    border-radius: 6px;
    z-index: 1;
    opacity: 0;
    transition: opacity 0.6s;
    bottom: 125%;
    left: 50%;
    margin-left: -60px;
    font-size: 0.75em;
  }

  /* Tooltip arrow */
  .tooltip:after {
    content: '';
    position: absolute;
    bottom: 75%;
    left: 50%;
    margin-left: -5px;
    border-width: 5px;
    border-style: solid;
    opacity: 0;
    transition: opacity 0.6s;
    border-color: #062b45 transparent transparent transparent;
  }

  .tooltip:hover:before,
  .tooltip:hover:after {
    opacity: 1;
  }
</style>
```