Postgresql - Select Distinct


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

Cypress 包含测试网站所必须的所有组件，可以快速编写测试用例。

## 下载源码

```bash
git clone github.com/ahfarmer/emoji-search
#安装依赖
cd emoji-search && npm install
#启动项目
npm run start
#访问http://localhost:3000
```

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

## 安装 Cypress

```bash
#安装
npm install cypress —save-dev

#启动
npx cypress open
#或者
./node_modules/.bin/cypress open
#或者
$(npm bin)/cypress open
```

以上命令将会在项目根目录创建`cypress`文件夹，如下： ![09GuGd](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/09GuGd.jpg)

## 创建测试用例

默认情况下，所有测试都存储在`cypress/integration`文件夹中，该文件夹在第一次`Cypress`启动时自动创建。在此示例中，我们将编写一个测试，该测试将：

检查输入单词`lollipop`后是否在页面上仅显示一个结果

检查标题类的标签是否包含正确的文本

首先在`cypress/integration`目录中创建一个`sample_spec.js`文件：

该文件应包含以下代码：

```js
describe('Sample test', () => {
  it('Search lollipop emoji', () => {
    cy.visit('http://localhost:3000/') // launch project website
    cy.get('input').type('lollipop') // enter 'lollipop' in search
    cy.get('.component-emoji-result-row').should('have.length', 1) // check if only 1 result is returned
    cy.contains('Lollipop').should('have.class', 'title') // check if returned element contains 'title' class
  })
})
```

你将会看到这样的窗口：

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

单击`sample_spec.js`后，将打开一个带有搜索引擎实例的窗口，您可以在其中实时预览执行的测试。结果应如下所示（请记住，带有示例性网站的项目应该正在运行）：

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


Cypress入门


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

JavaScript 是一种单线程的语言，意味着它只有一个调用栈和一个执行线程。当 JavaScript 执行一段代码时，它会按照代码的顺序将函数调用和表达式求值添加到调用栈中。调用栈是一种后进先出（LIFO）的数据结构，它保证了当前执行的代码是最后被添加到栈中的。

当 JavaScript 遇到异步代码时，它会将异步代码添加到任务队列中并继续执行后续代码。任务队列是一种先进先出（FIFO）的数据结构，它保证了先添加到队列中的任务会先被执行。

JavaScript 中的异步代码包括定时器、事件监听器、网络请求等。当这些异步操作完成时，它们会将回调函数添加到任务队列中。

当调用栈为空时，事件循环将从任务队列中取出一个任务并将其添加到调用栈中执行。当任务执行完成后，调用栈将被弹出，并且事件循环将继续从任务队列中取出下一个任务，直到任务队列为空。

在事件循环中，微任务队列是一种特殊类型的任务队列，它优先级高于任务队列。当任务队列中存在微任务时，事件循环将优先执行微任务队列中的任务，直到微任务队列为空。微任务包括 Promise 的回调函数和一些 DOM 操作的回调函数等。

当事件循环执行微任务时，它会一直执行微任务队列中的所有任务，直到微任务队列为空。然后它会继续从任务队列中取出下一个任务并执行，直到任务队列和微任务队列都为空。

事件循环包括以下几个主要概念：

- 调用栈（Call Stack）：调用栈是一种数据结构，它用于存储当前正在执行的函数调用的上下文信息。当一个函数被调用时，它的上下文信息被压入调用栈中，当函数执行完成时，它的上下文信息被从调用栈中弹出。
- 任务队列（Task Queue）：任务队列是一个队列，它用于存储待执行的任务。当一个任务被添加到任务队列中时，它会等待事件循环将它取出并执行。
- 事件循环（Event Loop）：事件循环是一个持续的过程，它不断地从任务队列中取出任务并执行它们。当调用栈为空时，事件循环将从任务队列中取出一个任务并将其压入调用栈中执行。
- 微任务队列（Microtask Queue）：微任务队列是一个队列，它用于存储微任务。微任务是一种特殊类型的任务，它会在当前任务执行完成后立即执行。微任务队列的优先级高于任务队列，这意味着当有微任务时，事件循环将先执行微任务队列中的所有任务，然后再执行任务队列中的任务。

事件循环的执行顺序如下：

- 当代码开始执行时，所有同步代码都会被按顺序添加到调用栈中执行。
- 如果遇到异步代码（例如定时器或事件监听器），则会将其添加到任务队列中并继续执行后续代码。
- 当调用栈为空时，事件循环将从任务队列中取出一个任务并将其压入调用栈中执行。
- 如果任务队列中有微任务，则事件循环将优先执行微任务队列中的所有任务，直到微任务队列为空。
- 重复执行步骤 3 和步骤 4，直到任务队列和微任务队列都为空


事件循环是每个前端开发必须理解的概念

事件循环


## API 中间件

`Next.js`提供了内置的路由中间件用于解析入参等。

- `req.cookies`：获取客户端的 cookie
- `req.query`：获取客户端的 query
- `req.body`：获取客户端的 body

```jsx
export default (req, res) => {
  res.statusCode = 200
  res.setHeader('Content-Type', 'application/json')
  res.end(JSON.stringify({query: req.query}))
}
```

## 配置跨域

你还可以使用 Connect 兼容的中间件，比如使用 `cors`：

```jsx
import Cors from 'cors'

// Initializing the cors middleware
const cors = Cors({
  methods: ['GET', 'HEAD']
})

// Helper method to wait for a middleware to execute before continuing
// And to throw an error when an error happens in a middleware
function runMiddleware(req, res, fn) {
  return new Promise((resolve, reject) => {
    fn(req, res, (result) => {
      if (result instanceof Error) {
        return reject(result)
      }

      return resolve(result)
    })
  })
}

async function handler(req, res) {
  // Run the middleware
  await runMiddleware(req, res, cors)

  // Rest of the API logic
  res.json({message: 'Hello Everyone!'})
}

export default handler
```


Next.js - API MiddleWares


xargs（英文全拼： eXtended ARGuments）是给命令传递参数的一个过滤器，也是组合多个命令的一个工具。

## 使用方法

```bash
command1 | xargs command2
```

我们使用**|**将输出传递给 xargs。这将负责运行 command2 命令，使用 command1 的输出作为其参数。

## 例子

让我们举一个简单的例子。您要从目录中删除某些特定文件。这些文件列在文本文件中。我们有 3 个文件：file1，file2，file3。在**todelete.txt**我们有一个要删除的文件列表，在本例中为 file1 和 file3：

```bash
cat todelete.txt

file1
file2
```

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

通过 cat 命令将 todelete 内容输出并执行 rm 命令

```bash
cat todelete.txt | xargs rm
```

## 参数

- -a file 从文件中读入作为 sdtin
- -e flag ，注意有的时候可能会是-E，flag 必须是一个以空格分隔的标志，当 xargs 分析到含有 flag 这个标志的时候就停止。
- -p 当每次执行一个 argument 的时候询问一次用户。
- -n num 后面加次数，表示命令在执行的时候一次用的 argument 的个数，默认是用所有的。
- -t 表示先打印命令，然后再执行。
- -i 或者是-I，这得看 linux 支持了，将 xargs 的每项名称，一般是一行一行赋值给 {}，可以用 {} 代替。
- -r no-run-if-empty 当 xargs 的输入为空的时候则停止 xargs，不用再去执行了。
- -s num 命令行的最大字符数，指的是 xargs 后面那个命令的最大命令行字符数。
- -L num 从标准输入一次读取 num 行送给 command 命令。
- -l 同 -L。
- -d delim 分隔符，默认的 xargs 分隔符是回车，argument 的分隔符是空格，这里修改的是 xargs 的分隔符。
- -x exit 的意思，主要是配合-s 使用。。
- -P 修改最大的进程数，默认是 1，为 0 时候为 as many as it can ，这个例子我没有想到，应该平时都用不到的吧。


xargs（英文全拼： eXtended ARGuments）是给命令传递参数的一个过滤器，也是组合多个命令的一个工具

Linux命令xargs


## 闭包的定义

闭包(Closures)是自包含的功能代码块，可以将闭包视为无名函数，可以将其分配给变量或将其作为参数传递给函数。
闭包主要用于在将来满足条件时执行某项操作。例如，成功下载文件后，将其内容存储到数据库中。

全局函数和嵌套函数其实就是特殊的闭包。

闭包的形式有：

| 全局函数               | 嵌套函数                       | 闭包表达式                                         |
| ---------------------- | ------------------------------ | -------------------------------------------------- |
| 有名字但不能捕获任何值 | 有名字，也能捕获封闭函数内的值 | 无名闭包，使用轻量级语法，可以根据上下文环境捕获值 |

## 创建闭包

```swift
let helloWorldClosure = {
  print("hello")
}

helloWorldClosure()
```

上面的代码创建一个打印`Hello`的闭包，并将该闭包分配给`helloWorldClosure`变量。然后，可以像调用函数一样简单地调用闭包。

## 接收参数

```swift
let driving = { (place: String) in
    print("I'm going to \(place) in my car")
}
driving("London")
```

## 闭包返回值

```swift
let addClosure = { (first: Int, second: Int) -> Int in
    return first + second
}

let sum = addClosure(1,2)
```

上面的代码创建一个以两个数字为参数的闭包，并返回数字的总和。

## 作为参数传递

```swift
let saveFile = {
   //code to save file
}

func downloadFile(imageUrl, onSuccess: () ->) {
  //code to download file
  if(downloadSuccessfull){
     onSuccess()
  }
}

downloadFile(imageUrl: "Instagram", onSuccess: saveFile)
```

闭包强制返回值，`()->Void`表示不接受参数并且不返回任何内容。可以将`Void`替换为任何类型，如`Int`或者`String`，强制闭包返回值。

```swift
func travel(action: (String) -> String) {
    print("I'm getting ready to go.")
    let description = action("London")
    print(description)
    print("I arrived!")
}

travel { (place: String) -> String in
    return "I'm going to \(place) in my car"
}

# 闭包简写
travel {
    return "I'm going to \($0) in my car"
}

# 多参数传递
func travel(action: (String, Int) -> String) {
    print("I'm getting ready to go.")
    let description = action("London", 60)
    print(description)
    print("I arrived!")
}

travel {
    return "I'm going to \($0) at \($1) in my car"
}
```

## 闭包总结

- 可以将闭包赋值给变量
- 闭包接收参数和返回值
- 可以将闭包作为参数传递到函数中，这些闭包可以有自己的参数和返回值。
- 如果函数的最后一个参数是闭包，则可以使用尾随闭包语法。
- Swift 自动提供速记参数名称，如$0 和$1，但并非所有人都使用它们。
- 如果在闭包中使用外部值，它们将被捕获，以便闭包稍后可以引用它们。


闭包(Closures)是自包含的功能代码块，可以在代码中使用或者用来作为参数传值。

Closures - 闭包


CSS 动画（CSS Animations）是一种使用 CSS 属性来实现元素动态变化的技术。它允许您在不使用 JavaScript 或 Flash 等技术的情况下，通过使用 CSS 属性来创建动态效果。

CSS 动画由两个主要组成部分组成：关键帧（Keyframes）和动画属性（Animation Properties）。

关键帧是指定义了动画在不同时间点上应该显示的样式。例如，您可以定义一个在动画开始时显示元素，然后在 50% 处旋转元素，最后在动画结束时将其变形的关键帧。

动画属性用于指定动画如何进行，包括动画持续时间、延迟、动画速度和重复次数等。通过指定这些属性，您可以控制动画的时序和执行方式。

下面是一个简单的 CSS 动画示例，该示例将使元素在 2 秒内从左侧滑动到右侧：

```css
/* 定义动画关键帧 */
@keyframes slide {
  from {
    margin-left: 0;
  }
  to {
    margin-left: 100px;
  }
}

/* 应用动画属性 */
.element {
  animation-name: slide;
  animation-duration: 2s;
}
```

在这个例子中，我们首先定义了一个名为 slide 的关键帧，该关键帧定义了元素的初始样式（from）和结束样式（to）。然后，我们将 slide 动画应用于一个类名为 .element 的元素，通过设置 animation-name 和 animation-duration 属性来指定动画名称和持续时间。

CSS 动画有许多属性可以用于自定义动画效果，包括动画延迟、动画速度、动画方向、动画填充模式等。通过熟练使用这些属性，您可以创建出非常丰富的动画效果，从简单的平移和旋转到复杂的路径动画和变形效果。
