Postgresql - Where


所有有效的 URL 都遵循某些规则。因此，如果了解了这些模规则，就可以确定 URL 是否有效。

- 如何使用`URL`构造器校验 URLs
- 如何使用 npm 包校验 URLs
- 如何使用正则校验 URLs

## 如何使用`URL`构造器校验 URLs

当向`URL`函数中传入字符串时，如果是有效的 url 会返回 url 对象，否则会抛出异常

```js
const fccUrl = new URL('https://www.freecodecamp.org/')
console.log(fccUrl)
```

控制台将输出以下内容：

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

当传入值是无效的 url 时:

freecodecamp 为无效的 url 链接，将抛出异常

```js
const fccUrl = new URL('freecodecamp')
console.log(fccUrl)
```

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

## 如何创建校验 url 有效性函数

```js
function isValidUrl(str) {
  try {
    new URL(str)
    return true
  } catch (e) {
    return false
  }
}

console.log(isValidUrl('https://www.freecodecamp.org/')) // true
console.log(isValidUrl('mailto://mail@freecodecamp.org')) // true
console.log(isValidUrl('freecodecamp')) // false
```

当传入值是有效 url，则返回 true，否则返回 false。

## 如何校验`http`url

有时需要区分 http 协议和其他协议，比如`mailto://mail@freecodecamp.org`

对`isValidUrl`函数做点改动，对返回的协议检查

```js
function isValidHttpUrl(str) {
  try {
    const newUrl = new URL(str)
    return newUrl.protocol === 'http:' || newUrl.protocol === 'https:'
  } catch (e) {
    return false
  }
}

console.log(isValidHttpUrl('https://www.freecodecamp.org/')) // true
console.log(isValidHttpUrl('mailto://mail@freecodecamp.org')) // false
console.log(isValidHttpUrl('freecodecamp')) // false
```

## 如何使用 npm 包校验

`is-url`、`is-url-http`

```js
import isUrl from 'is-url'
import isUrlHttp from 'is-url-http'

const firstCheck = isUrl('https://www.freecodecamp.org/')
const secondCheck = isUrl('mailto://mail@freecodecamp.org')
const thirdCheck = isUrl('freeCodeCamp')

console.log(firstCheck) // true
console.log(secondCheck) // true
console.log(thirdCheck) // false

const firstCheck = isUrlHttp('https://www.freecodecamp.org/')
const secondCheck = isUrlHttp('mailto://freecodecamp@mail.org')
const thirdCheck = isUrlHttp('freeCodeCamp')

console.log(firstCheck) // true
console.log(secondCheck) // false
console.log(thirdCheck) // false
```

## 如何使用正则校验

所有有效链接遵循以下几种规则

- 协议
- 域名或 ip
- 端口或路径

你可以在[【The structure of URLS】](https://www.freecodecamp.org/news/what-happens-when-you-hit-url-in-your-browser/)学习更多关于`URL 规则`

知道模式 URL 是由什么组成的，您可以使用正则表达式检查字符串中是否存在这样的模式。

如果模式存在，则字符串通过正则表达式测试。否则就会失败。

此外，使用正则表达式，您可以检查所有有效的 URL，或者只检查有效的 HTTP URL。

```js
function isValidUrl(str) {
  const pattern = new RegExp(
    '^([a-zA-Z]+:\\/\\/)?' + // protocol
      '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
      '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR IP (v4) address
      '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
      '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
      '(\\#[-a-z\\d_]*)?$', // fragment locator
    'i'
  )
  return pattern.test(str)
}

console.log(isValidUrl('https://www.freecodecamp.org/')) // true
console.log(isValidUrl('mailto://freecodecamp.org')) // true
console.log(isValidUrl('freeCodeCamp')) // false
```

校验协议并未严格限制`http`或`https`，所有`mailto`开头的协议会返回`true`，稍作改动仅校验`http`

```js
function isValidHttpUrl(str) {
  const pattern = new RegExp(
    '^(https?:\\/\\/)?' + // protocol
      '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
      '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
      '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
      '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
      '(\\#[-a-z\\d_]*)?$', // fragment locator
    'i'
  )
  return pattern.test(str)
}

console.log(isValidHttpUrl('https://www.freecodecamp.org/')) // true
console.log(isValidHttpUrl('mailto://freecodecamp.org')) // false
console.log(isValidHttpUrl('freeCodeCamp')) // false
```


如何校验URLs？


伪元素（Pseudo elements）是 CSS 中的一个重要概念，它允许开发者创建一个在文档树之外的元素，并且给这个元素添加样式，从而实现各种效果。

伪元素使用双冒号（::）来表示，与伪类选择器的单冒号（:）区分开来。伪元素可以用在 CSS 选择器中，表示要选择的元素的一部分。在选择器中使用伪元素时，它们会被插入到指定的元素之前或之后，并且可以用样式属性来设置它们的内容、颜色、位置等。

下面是常见的伪元素：

- ::before：在元素内容之前插入一个元素，常用来添加内容或图标等。
- ::after：在元素内容之后插入一个元素，常用来添加内容或图标等。
- ::first-line：选择元素的第一行文本，常用来设置文本的样式，如颜色、字体等。
- ::first-letter：选择元素的第一个字母，常用来设置文本的样式，如颜色、大小等。
- ::selection：选择用户选中的文本，常用来设置选中文本的样式，如背景颜色、字体颜色等。

伪元素的语法如下：

```bash
selector::pseudo-element {
/* styles */
}
```

在上面的代码中，selector 表示要选择的元素，pseudo-element 表示要使用的伪元素。例如，使用 ::before 伪元素在元素前插入一个内容为“hello”的元素，可以写成下面的代码：

```css
p::before {
  content: 'hello';
}
```

注意，伪元素必须有 content 属性，否则在页面上不会显示任何内容。此外，伪元素可以用来实现各种效果，如添加箭头、制作单选按钮、实现字体图标等。掌握伪元素的使用可以让你的 CSS 技能更上一层楼


css - Pseudo-elements


[示例数据库](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/dvdrental.zip)

使用数据库时，最常见的就是使用`SELECT`语句来查询数据。

`SELECT`语句是 Postgresql 最复杂的一种查询语句，它可以查询数据库中的所有数据，也可以查询指定的数据。

- `DISTINCT`查询不同行的数据
- `ORDER BY`排序查询结果
- `WHERE`条件过滤查询结果
- `LIMIT`或`FETCH`限制查询结果的数量
- `GROUP BY`分组查询结果
- `HAVING`条件过滤分组查询结果
- `INNER JOIN`内连接查询结果
- `LEFT JOIN`左连接查询结果
- `FULL OUTER JOIN`全连接查询结果
- `CROSS JOIN`交叉连接查询结果
- `UNION`查询结果的并集
- `INTERSECT`查询结果的交集
- `EXCEPT`查询结果的差集

## SELECT 语法

`SELECT [select_list] FROM [table_name]`

- select_list:指定一个或多个查询字段，也可以使用`*`来查询所有字段
- table_name:指定查询的表名

## SELECT 语句的示例

#### 查询所有客户的名字

```sql
SELECT first_name FROM customer;
```

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

> `;`表示语句结束

#### 查询多个字段

```sql
SELECT first_name, last_name, email FROM customer;
```

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

#### 查询所有数据

```sql
SELECT * FROM customer;
```

> 尽量避免使用`*`，因为它会查询所有字段，会影响性能。

#### 表达式查询

使用`||`连接姓名查询

```sql
SELECT first_name || ' ' || last_name, email FROM customer;
```

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

```sql
SELECT 5*3;
```

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


Postgresql - Select


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 - 函数


Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。

- useState
- useEffect
- useRef
- useContext
- useCallback
- useMemo

## 使用 useState

`useState` 可以让你在不编写 class 的情况下使用 state。

```jsx
import {useState} from 'react'

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

  function updateCount() {
    setCount(count + 1)
  }

  return <button onClick={updateCount}>Count is: {count}</button>
}
```

`useState`第一个参数是初始值，第二个参数是一个函数，这个函数可以更新初始值。

如果更新函数返回值与初始值相同，那么组件不会更新。否则将组件的重新渲染加入队列。

## 使用 useEffect

`useEffect(callback[, dependencies]);`

- `callback`是包含副作用逻辑的函数
- `dependencies`是一个数组，表示依赖的数据发生变化时，`callback`函数才会执行。

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

当`dependecies`未提供时，每次渲染都会执行`callback`函数。

当`dependencies`提供的是一个空数组时，`callback`函数只会执行一次。

当`dependencies`提供的是一个不为空的数组时，`callback`函数会在依赖的数据发生变化时执行。

```jsx
import {useEffect} from 'react'

function MyComponent() {
  useEffect(() => {
    // perform side effect here
  }, [])
}
```

[A Simple Explanation of React.useEffect()](https://dmitripavlutin.com/react-useeffect-explanation/)

## 使用 useRef

`useRef`允许直接访问 JSX 元素的 DOM 元素。

```jsx
import {useRef} from 'react'

function MyComponent() {
  const ref = useRef()

  return <div ref={ref} />
}
```

此时，可以使用`ref.current`访问到 DOM 元素。比如：

```jsx
import {useWindowEvent} from '@mantine/hooks'
import {useRef} from 'react'

function Header() {
  const inputRef = useRef()

  useWindowEvent('keydown', (event) => {
    if (event.code === 'KeyK' && event.ctrlKey) {
      event.preventDefault()
      inputRef.current.focus()
    }
  })

  return <input ref={inputRef} />
}
```

## 使用 useContext

`useContext`提供比`Context.Consumer`更简单的方式来访问 Context。比如：

```jsx
import { createContext, useContext } from 'react';

const NameContext = createContext('');

function App() {
  return (
    <NameContext.Provider value="John Doe">
      <Body />
    <NameContext.Provider>
  );
}

function Body() {
  return <Greeting />;
}

function Greeting() {
	const name = useContext(NameContext);

  return (
    <h1>Welcome, {name}</h1>
  );
}
```

## 使用 useCallback

`useCallback`返回一个 memoized 函数，这个函数会在组件的每次渲染时被调用。

`useCallback(fn,deps)`，类似于 vue 中的 computed

```jsx
function App() {
  const [player, setPlayer] = React.useState('')
  const [players, setPlayers] = React.useState(['Messi', 'Ronaldo', 'Laspada'])

  function handleChangeInput(event) {
    setPlayer(event.target.value)
  }
  function handleAddPlayer() {
    setPlayers(players.concat(player))
  }
  const handleRemovePlayer = useCallback(
    (player) => {
      setPlayers(players.filter((p) => p !== player))
    },
    [players]
  )

  return (
    <>
      <input onChange={handleChangeInput} />
      <button onClick={handleAddPlayer}>Add Player</button>
      <PlayerList players={players} handleRemovePlayer={handleRemovePlayer} />
    </>
  )
}

function PlayerList({players, handleRemovePlayer}) {
  return (
    <ul>
      {players.map((player) => (
        <li key={player} onClick={() => handleRemovePlayer(player)}>
          {player}
        </li>
      ))}
    </ul>
  )
}
```

## 使用 useMemo

`useMemo`返回一个 memoized 值，与`useEffect`、`useCallback`类似，接收函数和依赖项作为参数。

```jsx
import * as React from 'react'
import {getMDXComponent} from 'mdx-bundler/client'

function Post({code, frontmatter}) {
  const Component = React.useMemo(() => getMDXComponent(code), [code])

  return (
    <>
      <header>
        <h1>{frontmatter.title}</h1>
        <p>{frontmatter.description}</p>
      </header>
      <main>
        <Component />
      </main>
    </>
  )
}
```


Hook 是 React 16.8 的新增特性。它可以让你在不编写 class 的情况下使用 state 以及其他的 React 特性。

React Hooks


`string_decoder`用于把 Buffer 转换为字符串

## 基本用法

```js
const {StringDecoder} = require('string_decoder')
const decoder = new StringDecoder('utf8')
const buffer = Buffer.from('Hello World')
const str = decoder.write(buffer)
console.log(str)
```

## 方法

- stringDecoder.write(buffer[, encoding])
- stringDecoder.end(buffer[, encoding])

`write`方法把 buffer 转换为字符串，`end`方法把 buffer 转换为字符串并返回。

```js
const {StringDecoder} = require('string_decoder')
const decoder = new StringDecoder('utf8')

decoder.write(Buffer.from([0xe2]))
decoder.write(Buffer.from([0x82]))
console.log(decoder.end(Buffer.from([0xac])))
```


string_decoder用于把Buffer转换为字符串