如何判断是否是日期对象？


`Text` 视图是 `SwiftUI` 用户界面中最常用的元素之一。它们允许你向你的应用程序中添加文本，比如标签、标题、描述等等。在 `SwiftUI` 中，`Text`视图易于使用，只需要最少的代码，并提供很多的自定义选项。

若要创建 `Text` 视图，请使用 `Text` 初始值设定项并提供要在其中显示的文本。下面是如何创建显示简单消息的 `Text` 视图的示例:

```swift
struct ContentView: View {
  var body: some View {
    Text("Hello, World!")
  }
}
```

在 `ContentView` 结构中，我们定义`body`计算属性，该属性返回一个视图。在这里，我们使用 `Text` 视图创建一个文本视图的新实例，并使用“ `Hello，World!`”作为它的内容。

## 自定义文本视图

`Text` 视图是一个灵活而轻量级的视图，允许您自定义其字体、样式、颜色、大小、行间距以及更多使用修饰符。下面的示例说明如何通过添加`.font()`修饰语:

```swift
struct ContentView: View {
  var body: some View {
    Text("Hello, World!")
      .font(.largeTitle)
  }
}
```

上面的代码使用字体修饰符将 `Text` 视图的字体大小和样式定义为`.largeTitle`。是 `SwiftUI` 预定义的文本样式之一。这只是 `Text` 视图可以合并的众多修饰符之一。


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

Swift - 在 SwiftUI 中添加文本视图

![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>
```

一些有用的Html&&css&&javascript Tips


部署您的Flutter应用程序是应用程序开发过程的最后一步。这涉及为Android和iOS准备您的应用程序并构建发布版本。此外，我们还将介绍持续部署的概念以及如何使用GitHub Actions自动化部署过程。

## Android和iOS部署

### 为发布准备您的应用程序

在发布应用程序之前，您需要为其进行准备。这包括设置版本号、创建应用程序图标和配置构建设置。

- 设置版本号：版本号很重要，因为它向用户和Play商店通知应用程序的更新。您可以在pubspec.yaml文件中设置版本号。
- 创建应用程序图标：应用程序图标是用户在主屏幕上看到的内容。您可以使用在线工具创建应用程序图标，然后将其添加到您的项目中。
- 配置构建设置：构建设置确定应用程序的构建方式。您可以在Android的android/app/build.gradle文件和iOS的ios/Runner.xcworkspace文件中配置这些设置。

### 为Android构建发布APK

要为Android构建发布APK，您需要创建密钥库、在项目中引用该密钥库，然后构建APK。

- 创建密钥库：密钥库是包含一组私钥的二进制文件。您可以使用keytool命令创建密钥库。
- 在项目中引用密钥库：创建密钥库后，您需要在项目中引用它。可以通过在android目录中创建一个key.properties文件来实现这一点。
- 构建APK：最后，通过运行flutter build apk命令，您可以构建APK。

### 为iOS构建发布IPA

要为iOS构建发布IPA，您需要创建App Store Connect帐户、注册您的应用程序，然后构建IPA。

- 创建App Store Connect帐户：在App Store上发布应用程序需要一个App Store Connect帐户。您可以在App Store Connect网站上创建一个帐户。
- 注册您的应用程序：创建帐户后，您需要注册您的应用程序。可以通过在App Store Connect网站上创建一个新的iOS应用程序来实现这一点。
- 构建IPA：最后，通过运行flutter build ios命令，您可以构建IPA。

## 持续部署

持续部署是一种软件开发实践，其中代码更改会自动构建、测试和部署。这种实践的好处在于减少手动错误、提供更快的反馈并加快发布过程。

要为您的Flutter应用程序设置持续部署，可以使用GitHub Actions。GitHub Actions是GitHub提供的CI/CD服务，允许您自动化您的工作流程。

以下是使用GitHub Actions设置持续部署的步骤：

- 创建工作流程文件：工作流程文件是定义工作流程的YAML文件。您可以在 .github/workflows 目录中创建工作流程文件。
- 定义工作流程：创建工作流程文件后，您需要定义工作流程。这涉及指定触发器、作业、步骤和操作。
- 提交并推送更改：最后，您需要提交并推送更改。一旦您推送更改，GitHub Actions将自动运行您的工作流程。

遵循这些步骤，您可以自动化部署过程，并确保您的应用程序始终是最新的。


Deploying Flutter Applications


> 在本教程中，我们将探索 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-快速开发跨平台应用


在 Swift 中，属性是一个值或者一组值，它与特定的类、结构体或枚举相关联。属性可以是存储属性或计算属性。

## 存储属性

存储属性是一种将值存储到实例变量中的属性。存储属性可以是变量属性（用 var 关键字定义）或常量属性（用 let 关键字定义）。

下面是一个存储属性的示例：

```swift
struct Rectangle {
  var width = 0.0
  var height = 0.0
}

var rect = Rectangle()
rect.width = 10.0
rect.height = 20.0

print("width: \(rect.width), height: \(rect.height)") // 输出 width: 10.0, height: 20.0
```

在上面的示例中，我们定义了一个 Rectangle 结构体，它有两个存储属性 width 和 height。然后，我们创建了一个 Rectangle 实例 rect，并将其宽度设置为 10.0，高度设置为 20.0。最后，我们打印出了 rect 实例的宽度和高度。

## 计算属性

计算属性是一种不直接存储值，而是提供一个 getter 和一个可选的 setter 用于间接获取和设置值的属性。计算属性可以用于计算、转换或验证值。

下面是一个计算属性的示例：

```swift
struct Rectangle {
var width = 0.0
var height = 0.0

    var area: Double {
        return width * height
    }
}

var rect = Rectangle()
rect.width = 10.0
rect.height = 20.0

print("area: \(rect.area)") // 输出 area: 200.0
```

在上面的示例中，我们给 Rectangle 结构体添加了一个计算属性 area，它通过 getter 计算并返回矩形的面积。然后，我们创建了一个 Rectangle 实例 rect，并将其宽度设置为 10.0，高度设置为 20.0。最后，我们打印出了 rect 实例的面积。

## 属性观察器

属性观察器是一种用于监听属性值变化的属性，它允许在属性值被设置之前或之后执行自定义代码。属性观察器可以应用于存储属性和计算属性。

下面是一个属性观察器的示例：

```swift
class StepCounter {
  var totalSteps: Int = 0 {
    willSet(newTotalSteps) {
      print("About to set totalSteps to \(newTotalSteps)")
    }
    didSet {
      if totalSteps > oldValue {
        print("Added \(totalSteps - oldValue) steps")
      }
    }
  }
}

let stepCounter = StepCounter()
stepCounter.totalSteps = 10
stepCounter.totalSteps = 20
```

在上面的示例中，我们定义了一个 StepCounter 类，它有一个存储属性 totalSteps，并为该属性添加了一个属性观察器。属性观察器包括 willSet 和 didSet 两个方法，分别在属性值被设置之前和之后执行。在 willSet 方法中，我们打印出将要设置的属性值，而在 didSet 方法中，我们比较旧值和新值，并打印出添加的步数。

然后，我们创建了一个 StepCounter 实例 stepCounter，并分别将其 totalSteps 设置为 10 和 20。由于 totalSteps 的值发生了变化，属性观察器被调用，并输出了相关的日志信息。

## 延迟存储属性

延迟存储属性是一种将属性的初始化推迟到第一次使用该属性时的属性。延迟存储属性使用 lazy 关键字定义。

下面是一个延迟存储属性的示例：

```swift
class DataImporter {
  var filename = "data.txt"
  // 模拟数据导入的过程
}

class DataManager {
  lazy var importer = DataImporter()
  var data = [String]()
  // 这里是 DataManager 的其他方法和属性
}

let manager = DataManager()
manager.data.append("Some data")
manager.data.append("Some more data")

// 此时 importer 属性还未被创建
print(manager.importer.filename)

// 第一次访问 importer 属性时，它会被创建
```

在上面的示例中，我们定义了一个 DataImporter 类，它有一个 filename 存储属性和一个模拟数据导入的方法。然后，我们定义了一个 DataManager 类，它有一个 data 数组属性和一个延迟存储属性 importer。当我们创建一个 DataManager 实例 manager 时，importer 属性不会被创建，直到我们第一次访问它时。在第一次访问 importer 属性时，它会被创建，并执行 DataImporter 的初始化过程。最后，我们打印出了 importer 的 filename 属性。

总之，Swift 的属性提供了一种方便的方式来封装和访问与类、结构体或枚举相关联的值。不同类型的属性具有不同的特点和用途，您可以根据自己的需求选择适合的属性类型。


在 Swift 中，属性是一个值或者一组值，它与特定的类、结构体或枚举相关联。属性可以是存储属性或计算属性。

Swift - 属性


Swift 是一种适用于 iOS、macOS、watchOS 和 Apple tvOS app 开发的新编程语言。尽管如此，Swift的许多部分将从您在C和Objective-C中开发的经验中熟悉。

Swift提供所有基本C和Objective-C类型的版本，包括用于整数的Int、用于浮点值的Double和Float、用于布尔值的Bool和用于文本数据的String。Swift还提供了三种主要集合类型的强大版本，例如Array、Set和Dictionary，如Collection Types中所述。

与C一样，Swift使用变量通过标识名称存储和引用值。Swift还广泛使用其值无法更改的变量。这些被称为常数，比C中的常数强大得多。当您处理不需要更改的值时，整个Swift都使用常量，以使代码的意图更安全、更清晰。

除了熟悉的类型外，Swift还引入了Objective-C中没有的高级类型，例如元组。元组使您能够创建和传递值分组。您可以使用元组将函数中的多个值作为单个复合值返回。

Swift还引入了可选类型，用于处理缺少值的情况。可选的说“有一个值，它等于x”或“根本没有值”。使用可选选项类似于在Objective-C中使用带有指针的nil，但它们适用于任何类型，而不仅仅是类。可选选项不仅比Objective-C中的nil指针更安全、更具表现力，而且是Swift许多最强大功能的核心。

Swift是一种类型安全的语言，这意味着该语言可以帮助您清楚地了解代码可以使用的值类型。如果您的部分代码需要String，类型安全性会阻止您错误地将其传递给Int。同样，类型安全可防止您意外地将可选String传递给需要非可选String的代码。类型安全可帮助您尽早在开发过程中捕获和修复错误。

## 常量和变量

常量和变量将值分配给特定的标识符，以便您可以在代码中引用它们。常量的值一旦设置就无法更改，而变量的值可以更改。

### 声明常量和变量

您可以使用let关键字声明常量，使用var关键字声明变量。常量和变量的名称可以包含任何字符，包括Unicode字符：

```swift
let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0
```

常量和变量的名称不能包含空格、数学符号、箭头、保留的（或者非法的）Unicode代码点、连线和制表符。也不能以数字开头，但可以在名称的其他地方包含数字。

打印常量和变量的值：

```swift
print(maximumNumberOfLoginAttempts)
print(currentLoginAttempt)
```

使用反斜杠（\）将常量和变量的名称放在括号中，以在字符串插值中包含它们的当前值：

```swift
print("Maximum number of login attempts is \(maximumNumberOfLoginAttempts)")
```

### 类型标注

您可以在声明常量或变量时提供类型标注（type annotation），以明确常量或变量可以存储的值的类型。在类型标注后面加上一个冒号和空格，然后加上类型名称，以指定常量或变量可以存储的值的类型：

```swift
var welcomeMessage: String
```

类型标注是一种为常量或变量提供关于其允许存储的值类型的方法。它不会为常量或变量的值分配任何实际的值；它只是说明了常量或变量可以存储的值的类型。如果您在声明常量或变量时提供了类型标注，您可以在该常量或变量的赋值语句中省略对其类型的说明。类型标注的使用可以使您的代码更具可读性，因为它允许您立即知道常量或变量可以存储的值的类型。

## 注释

您可以使用单行注释（single-line comments）将注释嵌入到代码中。单行注释以两个正斜杠（//）开头：

```swift
// This is a comment
```

您可以使用多行注释（multi-line comments）将注释嵌入到代码中。多行注释以正斜杠后跟星号（/*）开头，以星号后跟正斜杠（*/）结尾：

```swift
/* This is also a comment
but is written over multiple lines. */
```

## 分号

Swift不要求您在每个语句结尾处使用分号（;），但是您可以使用分号将多个独立的语句写在同一行上：

```swift
let cat = "🐱"; print(cat)
```

## 整数

整数是没有小数部分的数字，例如42和-23。Swift提供了8、16、32和64位有符号和无符号整数类型。这些整数类型的名称与它们的位数相同，例如UInt8表示8位无符号整数，Int32表示32位有符号整数。

整数范围：

```swift
let minValue = UInt8.min
let maxValue = UInt8.max
```

## 浮点数

浮点数是有小数部分的数字，例如3.14159、0.1和-273.15。Swift提供了两种有符号的浮点数类型：

- Double表示64位浮点数。
- Float表示32位浮点数。

如果您需要在您的代码中选择浮点数类型，推荐使用Double类型，除非你特别需要它的性能。

## 类型安全和类型推断

Swift是一种类型安全（type-safe）语言。类型安全语言可以让您清楚地知道代码可以处理的值的类型。如果部分代码期望得到String，您就不能传递一个Int来代替。

Swift通过类型推断（type inference）来选择合适的类型。如果您没有明确指定类型，Swift使用类型推断来选择合适的类型。例如，如果您给一个新的浮点值赋值，Swift会推断您想要创建一个Double而不是Float：

```swift
let meaningOfLife = 42
// meaningOfLife is inferred to be of type Int
let pi = 3.14159
// pi is inferred to be of type Double
```

如果您在一行中声明多个同类型的值，您可以在一行中写出所有值，用逗号隔开，Swift会自动推断出这些值的类型：

```swift
let x = 0.0, y = 0.0, z = 0.0
```

## 数值型字面量

整数字面量可以被写作：

- 一个十进制数，没有前缀
- 一个二进制数，前缀是0b
- 一个八进制数，前缀是0o
- 一个十六进制数，前缀是0x

十进制数的例子：

```swift
let decimalInteger = 17
let binaryInteger = 0b10001       // 17 in binary notation
let octalInteger = 0o21           // 17 in octal notation
let hexadecimalInteger = 0x11     // 17 in hexadecimal notation
```

浮点字面量可以是十进制（没有前缀），或者是十六进制（前缀是0x）。十进制浮点字面量还可以有一个可选的指数（exponent），通过大写或小写的e来指定。十六进制浮点字面量必须有一个指数；指数通过大写或小写的p来指定。十进制浮点字面量的例子：

```swift
let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0
```

## 数值型类型转换

整数和浮点数类型转换必须显式指定类型：

```swift
let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)
// twoThousandAndOne is equal to 2001
```

## 类型别名

类型别名（type aliases）就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。

```swift
typealias AudioSample = UInt16
var maxAmplitudeFound = AudioSample.min
// maxAmplitudeFound is now 0
```

## 布尔值

Swift有一个基本的布尔（Boolean）类型，叫做Bool。布尔值指逻辑上的值，因为它们只能是真或者假。Swift提供两个布尔常量，true和false：

```swift
let orangesAreOrange = true
let turnipsAreDelicious = false
```

## 元组

元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。

```swift
let http404Error = (404, "Not Found")
// http404Error is of type (Int, String), and equals (404, "Not Found")
```

元组的内容可以分解（decompose）成单独的常量和变量，然后你就可以正常使用它们了：

```swift
let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)")
// Prints "The status code is 404"
print("The status message is \(statusMessage)")
// Prints "The status message is Not Found"
```

如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记：

```swift
let (justTheStatusCode, _) = http404Error
print("The status code is \(justTheStatusCode)")
// Prints "The status code is 404"
```

你也可以通过下标来访问元组中的单个元素，下标从零开始：

```swift
print("The status code is \(http404Error.0)")
// Prints "The status code is 404"
print("The status message is \(http404Error.1)")
// Prints "The status message is Not Found"
```

你可以在定义元组的时候给单个元素命名：

```swift
let http200Status = (statusCode: 200, description: "OK")
```

这个元组的名字叫做http200Status，它的类型是(Int, String)。你可以通过名字来获取元素的值：

```swift
print("The status code is \(http200Status.statusCode)")
// Prints "The status code is 200"
print("The status message is \(http200Status.description)")
// Prints "The status message is OK"
```

## 可选类型

Swift的可选类型（optional types）表示：

* 这个值可能有值，等于x
* 这个值可能没有值

可选类型有点像Objective-C中的nil指针，但是它们可以用于任何类型，不仅仅是类。可选类型表示的是值缺失，而不是值为nil。这样的设计可以让你避免在你的代码中使用nil值。


## 可选绑定

可选绑定（optional binding）用来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或变量。可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或变量。

```swift
if let constantName = someOptional {
    statements
}
```

## 隐式解析可选类型

有时候在变量的生命周期中，会确定一个可选类型变量总会有值。在这种情况下，每次都需要判断和解析可选值是非常麻烦的。这时候可以选择隐式解析可选类型（implicitly unwrapped optionals）。

```swift
let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // requires an exclamation point

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString // no need for an exclamation point
```

## 错误处理

Swift提供了一种在运行时表示和抛出错误的机制。这个机制让你能够表示和抛出你自己的错误，并且把函数抛出的错误传递到程序的某个地方。

```swift
enum VendingMachineError: ErrorType {
    case InvalidSelection
    case InsufficientFunds(coinsNeeded: Int)
    case OutOfStock
}

throw VendingMachineError.InsufficientFunds(coinsNeeded: 5)
```

## 断言和先决条件

断言和先决条件用来检查在运行时一个必要的条件是否为真。如果条件判断的结果为true，代码继续运行。如果条件判断的结果为false，代码执行结束，你的应用被终止。

```swift
let age = -3
assert(age >= 0, "A person's age cannot be less than zero")
// This assertion fails because -3 is not >= 0.

if age > 10 {
    print("You can ride the roller-coaster or the ferris wheel.")
} else if age >= 0 {
    print("You can ride the ferris wheel.")
} else {
    assertionFailure("A person's age can't be less than zero.")
}
// Prints "You can ride the ferris wheel."
```




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