Formatting - 格式化


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

## 异步处理历史

- 异步 callbacks：callbacks 即是将函数作为参数传递，当同步代码运行结束，就调用函数参数继续运行。
- Promise：
- Generator：
- async/await：

优缺点对比：

| 发展史        | 优点                                       | 缺点                                                                                                  |
| ------------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
| Callback      | 解决了同步问题                             | 回调地狱、可读性差、无法 try / catch 、无法 return                                                    |
| Promise       | 一定程度上解决了回调地狱的可读性           | 无法取消、任务多时，同样存在语义不清晰                                                                |
| Generator     | 可以控制函数的执行，可以配合 co 函数库使用 | 流程管理却不方便（即何时执行第一阶段、何时执行第二阶段                                                |
| async / await | 语义更清晰、简洁，内置执行器               | 认知不清晰可能会造成大量 await 阻塞（程序并不会等在原地，而是继续事件循环，等到响应后继续往下走）情况 |

## Promise

```js
let promise = new Promise(function (resolve, reject) {
  // code
})
promise
  .then(() => {
    // then
  })
  .catch((error) => {
    // console.log(error)
  })
  .finally((_) => {
    // finally
  })
```

`code`处是用于执行的代码，当`new Promise`创建时，自动执行。

`then`是定义在`Promise.prototype`上的用来处理状态改变时的回调函数。

参数`resolve`和`reject`是 JavaScript 自身提供的回调函数。当`code`呗执行后应该调用`resolve`或`reject`

- `resolve` 任务成功返回 value
- `reject` 任务失败返回`error`

当`promise`被`reject`的时候或者运行代码抛出错误异常如：`throw new Error('Whoops!')`，`catch`负责处理错误

`finaylly`是`promise`结束时，无论结果是`fulfilled`还是`rejected`都会执行的回调函数

内部属性：

- `state` 初始值`pending`，`resolve`的时候为`fullfilled`，`reject`的时候为`rejected`
- `result` 初始值`undefined`，`resolve`的时候为`value`，`reject`的时候为`error`对象

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

### Promise.all

执行多个 promise，并等待所有 promise 准备就绪，任意一个 promise 被 reject，都会立即出发 Promise.all 的 reject 并且返回该 promise 的 error

```js
let promise = Promise.all([
  /*promises*/
])

// 例子
let urls = [
  'https://api.github.com/users/iliakan',
  'https://api.github.com/users/remy',
  'https://api.github.com/users/jeresig'
]

// 将每个 url 映射（map）到 fetch 的 promise 中
let requests = urls.map((url) => fetch(url))

// Promise.all 等待所有任务都 resolved
Promise.all(requests).then((responses) =>
  responses.forEach((response) => alert(`${response.url}: ${response.status}`))
)
```

### Promise.allSettled

与 Promise.all 不同的是，Promise.allSettled 会等待所有 promise 完成，无论成功失败。

- `{status:"fulfilled", value:result}` 对于成功的响应
- `{status:"rejected", reason:error}` 对于 error。

### Promise.race

只要有一个准备就绪就返回其结果或者错误

```js
Promise.race([
  new Promise((resolve, reject) => setTimeout(() => resolve(1), 1000)),
  new Promise((resolve, reject) =>
    setTimeout(() => reject(new Error('Whoops!')), 2000)
  ),
  new Promise((resolve, reject) => setTimeout(() => resolve(3), 3000))
]).then(alert) // 1
```

### Promise.any

与 Promise.race 类似，Promise.any 等待的是第一个`fulfilled`，如果都`rejected`，则返回一个 error 数组

## async/await

Async/await 是以更舒适的方式使用 promise 的一种特殊语法，同时它也非常易于理解和使用。

async 会将其后面的函数的返回值封装成一个`Promise`对象，而 await 会等待这个`Promise`完成，并将其结果返回。

```js
async function hello() {
  return (greeting = await Promise.resolve('Hello'))
}

hello().then(alert)
```

错误处理

1. 使用`try...catch`捕获 async/await 运行程序中抛出的错误
2. **[await-to-js](https://www.npmjs.com/package/await-to-js)**，使用类 go 语言的方式处理（属于 1 的封装）


Async & Promise


在前一篇文章介绍了[Adding browser notification](/blog/translate/build-chrome-extenstions/adding-browser-notification)，这篇将学习如何创建重复的通知。

## 创建重复通知

为了实现重复通知，我们必须利用[alarm api](https://developer.chrome.com/docs/extensions/reference/alarms/)。这允许我们创建可以在指定时间发起通知。

首先更新`manifest.json`，以便获取使用`alarm`权限

```json
{
  "permissions": ["alarm", "notifications"]
}
```

定时发起通知需要后台运行的服务，在 v3 manifest，可以注册一个后台服务

```json
{
  "background": {
    "service_worker": "background.js"
  }
}
```

然后修改`App.jsx`

```jsx
export function App() {
  const createNotification = () => {
    chrome.alarms.create({
      periodInMinutes: 1
    })
    window.close()
  }

  const stopNotification = () => {
    chrome.alarms.clearAll()
    window.close()
  }
  return (
    <div className="flex flex-col items-center justify-center w-screen h-auto bg-indigo-400 p-4">
      <button
        className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 text-2xl px-4 rounded"
        onClick={createNotification}
      >
        Motivate me 🎉
      </button>
      <br />
      <button
        className="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 text-2xl px-4 rounded"
        onClick={stopNotification}
      >
        Stop motivating me 😅
      </button>
    </div>
  )
}
```

修改`background.js`

```js
chrome.alarms.onAlarm.addListener(() => {
  chrome.notifications.create({
    type: 'basic',
    iconUrl: 'icons/icon-48.png',
    title: 'Hi there 👋',
    message: 'Just a reminder that you rock!',
    buttons: [{title: 'I know ☺️'}],
    priority: 0
  })
})
```

## Source Code

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


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

Chrome插件开发 - Repeating notifications


在 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 - 尺寸单位


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


## 安装 mongodb

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

## 添加 mongodb 源

```bash
sudo vi /etc/yum.repos.d/mongodb-org.repo


[mongodb-org-3.4]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/3.4/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-3.4.asc
```

```bash
yum repolist
```

## 安装 mongodb

```bash
sudo yum install mongodb-org

启动
sudo systemctl start mongod

重载
sudo systemctl reload mongod

停止
sudo systemctl stop mongod

重启
sudo systemctl restart mongod

加入自启
sudo systemctl enable mongod

检查状态
systemctl status mongod

```


安装mongodb


“gunzip”命令的快速指南，用于解压缩 gzip 文件。

**gunzip**命令基本上等同于**gzip**命令，但默认情况-d 选项始终处于启用状态。

## 使用方法

```bash
gunzip filename.gz
```

这将**gunzip**并删除**.gz**扩展名，将结果放入文件名文件中。如果该文件存在，它将覆盖该文件。

可以使用-c 选项使用输出重定向将其提取到其他文件名：

```bash
gunzip -c filename.gz > anotherfilename
```

gunzip 命令可以在 Linux、macOS、WSL 和任何有 UNIX 环境的地方使用

## 参数

- `-a 或--ascii` 　使用 ASCII 文字模式。
- `-c 或--stdout` 或--to-stdout 　把解压后的文件输出到标准输出设备。
- `-f 或-force` 　强行解开压缩文件，不理会文件名称或硬连接是否存在以及该文件是否为符号连接。
- `-h 或--help` 　在线帮助。
- `-l 或--list` 　列出压缩文件的相关信息。
- `-L 或--license` 　显示版本与版权信息。
- `-n 或--no-name` 　解压缩时，若压缩文件内含有远来的文件名称及时间戳记，则将其忽略不予处理。
- `-N 或--name` 　解压缩时，若压缩文件内含有原来的文件名称及时间戳记，则将其回存到解开的文件上。
- `-q 或--quiet` 　不显示警告信息。
- `-r 或--recursive` 　递归处理，将指定目录下的所有文件及子目录一并处理。
- `-S<压缩字尾字符串>或--suffix<压缩字尾字符串> `　更改压缩字尾字符串。
- `-t 或--test` 　测试压缩文件是否正确无误。
- `-v 或--verbose` 　显示指令执行过程。
- `-V 或--version` 显示版本信息。


“gunzip”命令的快速指南，用于解压缩gzip文件。