从性能、打包大小、SEO来看，Next.js可能是最适合写blog的React框架。

Next.js - Switch Theme Mode


`zlib`模块提供通过 `Gzip` 和 `Deflate/Inflate` 实现的压缩功能

## 创建和使用压缩流

```js
const zlib = require('zlib')
const gzip = zlib.createGzip()
const fs = require('fs')
const inp = fs.createReadStream('input.txt')
const out = fs.createWriteStream('input.txt.gz')
inp.pipe(gzip).pipe(out)
// 在桌面创建 input.txt 和 input.txt.gz 文件
```

## 解压缩和创建文件

```js
const zlib = require('zlib')
const gunzip = zlib.createGunzip()
const fs = require('fs')
const inp = fs.createReadStream('input.txt.gz')
const out = fs.createWriteStream('input.txt')
inp.pipe(gunzip).pipe(out)

// 在桌面创建 input.txt 和 input.txt.gz 文件
```

```

```


zlib模块提供通过 Gzip 和 Deflate/Inflate 实现的压缩功能

Node.js - zlib


在本节中，我们将深入探讨如何为您的Flutter应用程序添加高级功能。具体而言，我们将重点介绍如何进行HTTP请求以及处理图像上传和显示。

## 发送HTTP请求

HTTP请求是与服务器交互的任何移动应用程序的关键部分。它们允许您的应用程序与服务器之间发送和接收数据。在Flutter中，我们可以使用http包来处理这些请求。

首先，您需要将http包添加到pubspec.yaml文件中：

```yaml
dependencies:
  flutter:
    sdk: flutter
  http: ^0.13.3
```

然后，在Dart文件中导入该包：

```dart
import 'package:http/http.dart' as http;
```

要获取数据，可以使用http.get()。以下是一个示例：

```dart
var url = Uri.parse('https://example.com/whatsit/create');
var response = await http.get(url);
```

记得处理HTTP请求期间可能发生的任何错误。您可以使用try-catch块来实现这一点。

## 图像上传和显示

处理图像是许多移动应用程序的常见需求。Flutter提供了image_picker包用于图像选择，并且您可以使用HTTP请求将这些图像上传到服务器。

首先，将image_picker包添加到pubspec.yaml文件中：

```yaml
dependencies:
  flutter:
    sdk: flutter
  image_picker: ^0.8.4
```

然后，在Dart文件中导入该包：

```dart
import 'package:image_picker/image_picker.dart';
```

要选择图像，可以使用ImagePicker().getImage()。以下是一个示例：

```dart
final picker = ImagePicker();
final pickedFile = await picker.getImage(source: ImageSource.gallery);
```

要将所选图像上传到服务器，可以使用http.MultipartRequest()。以下是一个示例：

```dart
var request = http.MultipartRequest('POST', Uri.parse('https://example.com/upload'));
request.files.add(await http.MultipartFile.fromPath('picture', pickedFile.path));
var response = await request.send();
```

要从URL显示图像，可以使用Image.network()小部件。以下是一个示例：

```dart
Image.network('https://example.com/path/to/your/image.jpg')
```

通过本单元的学习，您应该能够在Flutter应用程序中进行HTTP请求，处理图像上传和显示。请记得始终处理可能的错误和异常，以确保应用程序运行顺畅。


Adding Advanced Features to Your Flutter Application


> 在本教程中，我们将探索 Tauri，一个用于构建桌面应用程序的现代跨平台框架。

多年来，==Electron== 实际上是构建桌面应用程序的跨平台框架。Visual Studio Code、 MongoDB Compass 和 Postman 都是使用这个框架构建应用程序的很好的例子。==Electron==无疑是伟大的，但它也有一些显著的缺点，这些缺点是其他一些现代框架所克服的ーー==Tauri==是其中最好的一个。

## 什么是 Tauri？

Tauri 是一个现代的框架，允许你在前端使用熟悉的网络技术(如 HTML、 CSS 和 JavaScript)设计、开发和构建跨平台应用，同时利用后端强大的 Rust 编程语言。

Tauri 是框架不可知论者。这意味着您可以将它与您选择的任何前端库一起使用ーー比如 Vue、 React、 Svelte 等等。此外，在基于 Tauri 的项目中使用 Rust 是完全可选的。你可以使用 Tauri 提供的 JavaScriptAPI 来构建你的整个应用。这样不仅可以很容易地构建一个新的应用程序，而且可以将已经构建的 Web 应用程序的代码库转换为本地桌面应用程序，而几乎不需要修改原始代码。

让我们看看为什么我们应该用 Tauri 而不是 Electron。

## Tauri vs Electron

开发应用有三大要素：小、快、安全，Tauri 在这三方面都优于 Electron。

1. 更小

参考[Tauri 发布的基准测试结果](https://tauri.app/v1/references/benchmarks)，即使是最小的`hello world`，Electron 的应用大小也超过了 120MB，而使用 Tauri 开发的应用仅仅 2MB

2. 更快

参考[Tauri 发布的基准测试结果](https://tauri.app/v1/references/benchmarks)，你还可以看到 Tauri 应用程序的内存使用量可能是同等 Electron 应用程序的近一半。

3. 更安全

在 Tauri 的网站上，你可以阅读到 Tauri 默认提供的所有内置安全特性。开发人员可以显式地启用或禁用某些 API。这不仅使你的应用程序更安全，而且还减少了二进制文件的大小。

## 开发笔记应用

这里，我们开发一个简单的笔记应用，包括以下特性：

- 增加、删除笔记
- 重命名笔记标题
- 支持 markdown 编辑
- 支持预览
- 支持本地存储
- 支持导入导出

源码:[Source Code](https://github.com/sitepoint-editors/my-notes)

## 开始

首先，需要[安装 Rust 开发环境](https://tauri.app/v1/guides/getting-started/prerequisites)。

使用脚手架创建 Tauri 应用

```bash
pnpm create tauri-app notes
.../Library/pnpm/store/v3/tmp/dlx-98609  |   +2 +
Packages are hard linked from the content-addressable store to the virtual store.
  Content-addressable store is at: /Users/xxx/Library/pnpm/store/v3
  Virtual store is at:             ../../Library/pnpm/store/v3/tmp/dlx-98609/node_modules/.pnpm
.../Library/pnpm/store/v3/tmp/dlx-98609  | Progress: resolved 10, reused 0, downloaded 2, added 2, done

✔ Choose your package manager · pnpm
✔ Choose your UI template · react-ts

Please follow https://tauri.app/v1/guides/getting-started/prerequisites to install the needed prerequisites, if you haven't already.

Done, Now run:
  cd notes
  pnpm install
  pnpm tauri dev
```

安装依赖

```bash
pnpm add @chakra-ui/react @emotion/react @emotion/styled framer-motion marked-react react-icons rooks
```

项目目录结构

```bash
├── README.md
├── index.html
├── package.json
├── pnpm-lock.yaml
├── public
│ ├── tauri.svg
│ └── vite.svg
├── src
│ ├── App.css
│ ├── App.tsx
│ ├── assets
│ ├── main.tsx
│ ├── style.css
│ └── vite-env.d.ts
├── src-tauri
│ ├── Cargo.lock
│ ├── Cargo.toml
│ ├── build.rs
│ ├── icons
│ ├── src
│ ├── target
│ └── tauri.conf.json
├── tsconfig.json
├── tsconfig.node.json
└── vite.config.ts
```

`src`存放 React 相关，`src-tauri`存放 rust 相关，配置修改相关的是`tauri.conf.json`，通常情况使用默认的即可

比如修改`allowlist`：

```json
{
  "allowlist": {
    "dialog": {
      "save": true,
      "open": true,
      "ask": true
    },
    "fs": {
      "writeFile": true,
      "readFile": true,
      "scope": ["$DOCUMENT/*", "$DESKTOP/*"]
    },
    "path": {
      "all": true
    },
    "notification": {
      "all": true
    }
  }
}
```

在`fs`里面特别声明了`scope`，`Documents`和`Desktop`，允许用户将笔记导出到这两个文件夹。

还需要修改`bundle`值，更改`identifier`为`com.mynotes.dev`，保证标识符唯一。

`windows`设置

```json
{
  "windows": [
    {
      "fullscreen": false,
      "height": 600,
      "resizable": true,
      "title": "My Notes",
      "width": 800
    }
  ]
}
```

然后启动服务`pnpm run tauri dev`，您需要等待一段时间，直到 Tauri 设置完成，所有文件都是第一次编译。

别担心。在随后的构建中，这个过程会快得多。当 Tauri 准备好了，它会自动打开应用程序窗口。下面的图片显示了您应该看到的内容。

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

> 在应用程序以开发模式运行或构建完成后，将在 `src-tauri` 中创建一个新的目标目录，其中包含所有已编译的文件。在 `dev` 模式下，它们被放置在 `debug` 子目录中，在构建模式下，它们被放置在 `release` 子目录中。

删除`index.css`、`App.css`，修改`main.tsx`，内容如下：

```tsx
import React from 'react'
import ReactDOM from 'react-dom/client'
import {ChakraProvider} from '@chakra-ui/react'
import App from './App'

const rootElement = document.getElementById('root')
ReactDOM.createRoot(rootElement).render(
  <React.StrictMode>
    <ChakraProvider>
      <App />
    </ChakraProvider>
  </React.StrictMode>
)
```

修改`App.tsx`，内容如下：

```tsx
import {useState} from 'react'
import {Button} from '@chakra-ui/react'

function App() {
  const [count, setCount] = useState(0)

  return (
    <div>
      <Button onClick={() => setCount((count) => count + 1)}>
        count is {count}
      </Button>
    </div>
  )
}

export default App
```

现在应用展示如下：

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

如果有什么问题，可以右键`inspect`进行调试。

修改`App.tsx`，替换内容如下：

```tsx
import {useState} from 'react'
import Markdown from 'marked-react'

import {
  ThemeIcon,
  Button,
  CloseButton,
  Switch,
  NavLink,
  Flex,
  Grid,
  Divider,
  Paper,
  Text,
  TextInput,
  Textarea
} from '@chakra-ui/react'
import {useLocalstorageState} from 'rooks'
import {
  IconNotebook,
  IconFilePlus,
  IconFileArrowLeft,
  IconFileArrowRight
} from '@tabler/icons'

import {save, open, ask} from '@tauri-apps/api/dialog'
import {writeTextFile, readTextFile} from '@tauri-apps/api/fs'
import {sendNotification} from '@tauri-apps/api/notification'

function App() {
  const [notes, setNotes] = useLocalstorageState({
    key: 'my-notes',
    defaultValue: [
      {
        title: 'New note',
        content: ''
      }
    ]
  })

  const [active, setActive] = useState(0)
  const [title, setTitle] = useState('')
  const [content, setContent] = useState('')
  const [checked, setChecked] = useState(false)

  const handleSelection = (title: string, content: string, index: number) => {
    setTitle(title)
    setContent(content)
    setActive(index)
  }

  const addNote = () => {
    notes.splice(0, 0, {title: 'New note', content: ''})
    handleSelection('New note', '', 0)
    setNotes([...notes])
  }

  const deleteNote = async (index: number) => {
    let deleteNote = await ask('Are you sure you want to delete this note?', {
      title: 'My Notes',
      type: 'warning'
    })
    if (deleteNote) {
      notes.splice(index, 1)
      if (active >= index) {
        setActive(active >= 1 ? active - 1 : 0)
      }
      if (notes.length >= 1) {
        setContent(notes[index - 1].content)
      } else {
        setTitle('')
        setContent('')
      }
      setNotes([...notes])
    }
  }

  return (
    <div>
      <Grid grow m={10}>
        <Grid.Col span="auto">
          <Flex gap="xl" justify="flex-start" align="center" wrap="wrap">
            <Flex>
              <ThemeIcon
                size="lg"
                variant="gradient"
                gradient={{from: 'teal', to: 'lime', deg: 90}}
              >
                <IconNotebook size={32} />
              </ThemeIcon>
              <Text color="green" fz="xl" fw={500} ml={5}>
                My Notes
              </Text>
            </Flex>
            <Button onClick={addNote} leftIcon={<IconFilePlus />}>
              Add note
            </Button>
            <Button.Group>
              <Button variant="light" leftIcon={<IconFileArrowLeft />}>
                Import
              </Button>
              <Button variant="light" leftIcon={<IconFileArrowRight />}>
                Export
              </Button>
            </Button.Group>
          </Flex>

          <Divider my="sm" />

          {notes.map((note, index) => (
            <Flex key={index}>
              <NavLink
                onClick={() => handleSelection(note.title, note.content, index)}
                active={index === active}
                label={note.title}
              />
              <CloseButton
                onClick={() => deleteNote(index)}
                title="Delete note"
                size="xl"
                iconSize={20}
              />
            </Flex>
          ))}
        </Grid.Col>
        <Grid.Col span={2}>
          <Switch
            label="Toggle Editor / Markdown Preview"
            checked={checked}
            onChange={(event) => setChecked(event.currentTarget.checked)}
          />

          <Divider my="sm" />

          {checked === false && (
            <div>
              <TextInput mb={5} />
              <Textarea minRows={10} />
            </div>
          )}
          {checked && (
            <Paper shadow="lg" p={10}>
              <Text fz="xl" fw={500} tt="capitalize">
                {title}
              </Text>

              <Divider my="sm" />

              <Markdown>{content}</Markdown>
            </Paper>
          )}
        </Grid.Col>
      </Grid>
    </div>
  )
}

export default App
```

以上代码解释：

1. 导入必要的包

- markdown 解析
- Mantine 组件
- hooks
- 图标
- Tauri apis

```ts
import {useState} from 'react'
import Markdown from 'marked-react'

import {
  ThemeIcon,
  Button,
  CloseButton,
  Switch,
  NavLink,
  Flex,
  Grid,
  Divider,
  Paper,
  Text,
  TextInput,
  Textarea
} from '@chakra-ui/react'
import {useLocalStorage} from '@mantine/hooks'
import {
  IconNotebook,
  IconFilePlus,
  IconFileArrowLeft,
  IconFileArrowRight
} from '@tabler/icons'

import {save, open, ask} from '@tauri-apps/api/dialog'
import {writeTextFile, readTextFile} from '@tauri-apps/api/fs'
import {sendNotification} from '@tauri-apps/api/notification'
```

2. 使用`localStorage`存储笔记

使用上一步导入的 hooks 的`useLocalStorage`处理存储

```ts
const [notes, setNotes] = useLocalStorage({
  key: 'my-notes',
  defaultValue: [
    {
      title: 'New note',
      content: ''
    }
  ]
})

const [active, setActive] = useState(0)
const [title, setTitle] = useState('')
const [content, setContent] = useState('')
const [checked, setChecked] = useState(false)

const handleSelection = (title: string, content: string, index: number) => {
  setTitle(title)
  setContent(content)
  setActive(index)
}
```

3. 增删函数

`addNote`、`handleSelection`进行存储操作，`deleteNote`函数使用`ask`弹窗询问是否删除

```ts
const addNote = () => {
  notes.splice(0, 0, {title: 'New note', content: ''})
  handleSelection('New note', '', 0)
  setNotes([...notes])
}

const deleteNote = async (index: number) => {
  let deleteNote = await ask('Are you sure you want to delete this note?', {
    title: 'My Notes',
    type: 'warning'
  })
  if (deleteNote) {
    notes.splice(index, 1)
    if (active >= index) {
      setActive(active >= 1 ? active - 1 : 0)
    }
    if (notes.length >= 1) {
      setContent(notes[index - 1].content)
    } else {
      setTitle('')
      setContent('')
    }
    setNotes([...notes])
  }
}
```

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

## 编辑&更新笔记函数

在`deleteNote`函数后添加一下函数

```ts
const updateNoteTitle = ({target: {value}}: {target: {value: string}}) => {
  notes.splice(active, 1, {title: value, content: content})
  setTitle(value)
  setNotes([...notes])
}

const updateNoteContent = ({target: {value}}: {target: {value: string}}) => {
  notes.splice(active, 1, {title: title, content: value})
  setContent(value)
  setNotes([...notes])
}
```

点击删除将会出现以下弹窗

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

## 增加导入导出功能

在`updateNoteContent`函数后添加以下函数

```ts
const exportNotes = async () => {
  const exportedNotes = JSON.stringify(notes)
  const filePath = await save({
    filters: [
      {
        name: 'JSON',
        extensions: ['json']
      }
    ]
  })
  await writeTextFile(`${filePath}`, exportedNotes)
  sendNotification(
    `Your notes have been successfully saved in ${filePath} file.`
  )
}

const importNotes = async () => {
  const selectedFile = await open({
    filters: [
      {
        name: 'JSON',
        extensions: ['json']
      }
    ]
  })
  const fileContent = await readTextFile(`${selectedFile}`)
  const importedNotes = JSON.parse(fileContent)
  setNotes(importedNotes)
}
```

`exportNotes`将笔记转换为 json，并通过 tauri save 弹窗，使用`writeTextFile`保存，保存成功后通过`sendNotification`函数通知用户。

`importNotes`调用 tauri open 弹窗，选择 json 文件，使用`readTextFile`转换为对象并更新到新的笔记。

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

导出通知信息如下：

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

## 构建 App

```bash
pnpm run tauri build
```

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


Tauri-快速开发跨平台应用


Logical Properties 是 CSS3 中引入的一个新特性，它是一个基于逻辑方向的属性系统，主要是为了支持从右向左（RTL）语言的页面设计而引入的。在传统的 CSS 盒模型中，宽度和高度、内边距和边框等属性都是基于物理方向来计算的（如左、右、上、下等），而在 RTL 语言中，这些属性需要根据从右向左的方向来计算。Logical Properties 则提供了一种基于逻辑方向的属性系统，这些属性会自动根据文本的方向进行翻转，从而能够更方便地支持多种语言和布局方式。

Logical Properties 包括以下几种属性：

- inline-size 和 block-size：代表元素的宽度和高度，根据文本的方向而自动调整。
- margin-inline 和 margin-block：代表元素的内边距，也可以用于设置外边距。
- padding-inline 和 padding-block：代表元素的内边距。
- border-inline 和 border-block：代表元素的边框。

其中，inline-size 和 block-size 可以理解为宽度和高度的逻辑属性，可以根据文本方向自动切换。而 margin-inline 和 padding-inline 则代表文本方向上的外边距和内边距，而 margin-block 和 padding-block 则代表块方向上的外边距和内边距。

例如，如果要在一个从右向左的页面中，将一个 div 元素水平居中，可以使用以下代码：

```css
div {
  margin-left: auto;
  margin-right: auto;
  margin-inline-start: 0;
  margin-inline-end: 0;
}
```

在上述代码中，margin-left 和 margin-right 控制了 div 元素的左右外边距，而 margin-inline-start 和 margin-inline-end 控制了 div 元素在文本方向上的外边距，从而实现了水平居中的效果。

需要注意的是，Logical Properties 只在支持 CSS3 的浏览器中才能使用。如果需要在旧版浏览器中使用 Logical Properties，可以考虑使用 Polyfill 或者手动转换为传统的物理属性来实现。


css - Spacing


在 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)是为类、结构体或枚举类型中的属性设置初始值的过程。

Swift - 初始化


可选链（Optional Chaining）是 Swift 中一种用于在调用属性、方法或下标脚本时处理值可能为空的机制。

在 Swift 中，如果一个对象的属性或方法返回值类型是可选类型（Optional Type），则在访问这个属性或方法时，需要使用可选链来避免空值引用导致的运行时错误。

可选链使用问号 ? 表示，如果一个属性、方法或下标脚本可能为空，则在其名称后面加上问号 ? 表示可选链：

```swift
class Person {
    var name: String?
}

let person: Person? = Person()

// 如果 person 为 nil，则不执行 name 的赋值操作
person?.name = "Tom"
```

在上述示例中，如果 person 对象为空，即使尝试给 name 属性赋值也不会引发运行时错误。

同时，可选链也可以用于调用方法或下标脚本：

```swift
class Person {
    var name: String?

    func sayHello() {
        print("Hello, my name is \(name ?? "")")
    }

    subscript(index: Int) -> String? {
        return name
    }
}

let person: Person? = Person()

// 如果 person 为空，则不执行 sayHello 方法
person?.sayHello()

// 如果 person 为空，则返回 nil
let name = person?[0]
```

在上述示例中，使用可选链调用 sayHello 方法和获取下标脚本，即使 person 为空也不会引发运行时错误。

需要注意的是，当使用可选链调用属性或方法时，如果这个属性或方法返回的是非可选类型，那么返回的值会被自动包装为可选类型。因此，当使用可选链调用方法或属性后需要对返回的值进行解包。

```swift
class Person {
    var name: String?

    func sayHello() {
        print("Hello, my name is \(name ?? "")")
    }

    func getAge() -> Int {
        return 18
    }
}

let person: Person? = Person()

// 返回值为可选类型，需要对返回值进行解包
let age = person?.getAge()

// age 的类型为 Optional<Int>，需要对其进行解包
if let age = age {
  print(age)
}
```

在上述示例中，调用 getAge 方法返回的是一个 Int 类型，但是由于使用了可选链，返回的值被自动包装成了可选类型，需要对其进行解包。


可选链（Optional Chaining）是 Swift 中一种用于在调用属性、方法或下标脚本时处理值可能为空的机制。