Postgresql - Column Aliases


回调是函数的异步等价物，在每个任务完成时调用它。

在 Node.js 中，回调通常被使用。Node 的所有 api 都是以支持回调的方式编写的。

例如: 当一个函数开始读取文件时，它会立即将控件返回给执行环境，以便执行下一条指令。

在 Node.js 中，一旦文件 i/o 完成，它将调用回调函数。因此没有阻塞或等待文件 i/o。

这使得 Node.js 具有高度的可伸缩性，因为它可以处理大量的请求，而无需等待任何函数返回结果。

## 同步获取文件内容

```js
var fs = require('fs')
var data = fs.readFileSync('input.txt')
console.log(data.toString())
console.log('Program 已经结束')
```

## 异步获取文件内容

```js
var fs = require('fs')

fs.readFile('input.txt', function (err, data) {
  if (err) return console.error(err)
  console.log(data.toString())
})
console.log('Program 已经结束')
```


A "callback" is any function that is called by another function which takes the first function as a parameter. （在一个函数中调用另外一个函数就是callback）

Node.js - Callbacks


布局（Layout）是指如何在页面中安排和组织 HTML 元素的位置和大小，是 Web 前端开发中至关重要的一环。

在 CSS 中，布局可以通过不同的布局方式来实现，主要包括以下几种：

- 流动布局（Flow Layout）：默认的布局方式，HTML 元素按照文档流从上到下依次排列，每个元素占据一定的空间，如果空间不足则会自动换行。流动布局是最常用的一种布局方式，也是响应式设计的基础。
- 浮动布局（Float Layout）：元素通过 float 属性向左或向右浮动，脱离文档流并且会覆盖在其他元素之上。浮动元素的周围的内容会环绕在其周围，可以用于实现多栏布局、图片与文本混排等效果。但是浮动布局有时会导致布局失效或者与其他元素重叠，需要注意清除浮动。
- 定位布局（Position Layout）：元素通过 position 属性进行定位，可以相对于文档、相对于父元素或相对于其他元素进行定位。定位布局常用于实现层叠效果、悬浮菜单、弹出框等效果。
- 弹性盒子布局（Flexbox Layout）：通过 display: flex 属性来设置元素为弹性盒子，可以定义主轴和交叉轴的方向，以及子元素在主轴和交叉轴上的对齐方式、分配比例等，是一种相对灵活的布局方式，适合于实现响应式设计和动态布局。
- 网格布局（Grid Layout）：通过 display: grid 属性来设置元素为网格容器，可以在水平和垂直方向上划分出多行多列的网格单元格，并且可以通过 grid-template-rows、grid-template-columns、grid-template-areas 等属性来设置单元格的大小、位置、内容等，是一种非常灵活的布局方式，适合于实现复杂的页面布局。

除了以上几种布局方式，还可以通过使用框架（如 Bootstrap、Foundation 等）或者 CSS Grid 系统（如 Bootstrap Grid、Semantic UI Grid 等）来快速构建布局，提高开发效率。

以下是一个使用 CSS Grid 布局实现的响应式网格布局案例：

HTML 代码：

```html
<div class="grid-container">
  <div class="grid-item">1</div>
  <div class="grid-item">2</div>
  <div class="grid-item">3</div>
  <div class="grid-item">4</div>
  <div class="grid-item">5</div>
  <div class="grid-item">6</div>
  <div class="grid-item">7</div>
  <div class="grid-item">8</div>
  <div class="grid-item">9</div>
</div>
```

CSS 代码：

```css
.grid-container {
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
  grid-gap: 20px;
}

.grid-item {
  background-color: #ddd;
  padding: 20px;
  text-align: center;
  font-size: 24px;
}
```

在这个案例中，我们使用了 CSS Grid 的自适应列宽功能来实现响应式布局。具体来说，我们使用 grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); 来定义网格容器的列宽，其中 auto-fit 表示根据容器大小自动调整列数，minmax(200px, 1fr) 表示每列的最小宽度为 200 像素，最大宽度为 1 个网格单元格的剩余空间。通过这种方式，我们可以让网格容器自动适应不同的屏幕尺寸，同时保证每列的宽度合适。

## 双飞翼布局

双飞翼布局是一种基于 CSS 的三列布局方式，它可以让页面的内容更加灵活地适应不同的屏幕尺寸和浏览器窗口大小。下面是一个简单的双飞翼布局示例：

HTML 代码：

```html
<div class="wrapper">
  <div class="content">
    <p>
      Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum eget
      ipsum id quam luctus rutrum nec eu nulla.
    </p>
  </div>
  <div class="left">
    <p>Left Column</p>
  </div>
  <div class="right">
    <p>Right Column</p>
  </div>
</div>
```

CSS 代码：

```css
.wrapper {
  width: 100%;
  max-width: 960px;
  margin: 0 auto;
  display: flex;
}

.content {
  flex-grow: 1;
  margin: 0 200px;
  background-color: #eee;
}

.left,
.right {
  width: 200px;
  margin-left: -200px;
  position: relative;
}

.left {
  float: left;
  background-color: #ccc;
}

.right {
  float: right;
  background-color: #ddd;
}
```

在这个布局中，.content 元素是页面的主要内容区域，.left 和 .right 元素分别是左右两栏。通过使用 flex 属性和 margin 属性来控制 .content 的宽度和位置，同时使用负的 margin-left 属性来将 .left 和 .right 移动到正确的位置。通过设置 position: relative 属性，可以保证 .left 和 .right 相对于 .content 定位，从而不会影响页面的布局。


css - layout


Next.js 的静态资源存储，将静态资源放到根目录的 public 文件夹下即可。

在 Next.js 里，页面即组件，每个页面通过文件系统路由关联起来。

创建 public 文件夹，将图片放到该文件夹，修改 first.js

```js
import Link from 'next/link'

export default function FirstPost() {
  return (
    <>
      <h1>My First Post</h1>
      <h2>
        <Link href="/">
          <a>Home</a>
        </Link>
      </h2>
      <br />
      <img src="/logo.png" alt="TS" />
    </>
  )
}
```

启动服务

```bash
npm run dev
```

查看效果

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


Next.js的静态资源存储，将静态资源放到根目录的public文件夹下即可

Next.js - Static File Serving


## 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


`pages/api` 目录下的任何文件都将作为 `API` 端点映射到 `/api/*`，而不是 `page`。这些文件只会增加服务端文件包的体积，而不会增加客户端文件包的大小。

`Next.js`中创建 rest api 的方式如下：

```jsx
export default (req, res) => {
  console.log(req, res)
  return {}
}
```

- req: 请求对象，http.IncomingMessage 实例
- res: 响应对象，http.ServerResponse 实例

## 响应

- `res.status(code)`：设置响应状态码
- `res.json(data)`：设置响应数据
- `res.send(data)`：设置响应数据
- `res.redirect(url)`：重定向

创建一个响应：

```jsx
export default function handler(req, res) {
  res.status(200).json({message: 'Hello from Next.js!'})
}
```

## 创建路由

创建一个简单的 rest api

```jsx
export default (req, res) => {
  res.statusCode = 200
  res.setHeader('Content-Type', 'application/json')
  res.json({
    message: 'Hello World'
  })
}
```

创建动态 API 路由：`pages/api/post/[pid].js`

```jsx
export default function handler(req, res) {
  const {pid} = req.query
  res.end(`Post: ${pid}`)
}
```

创建匹配所有路由：`pages/api/post/[...slug].js`

```jsx
export default function handler(req, res) {
  const {slug} = req.query
  res.end(`Post: ${slug.join(', ')}`)
}
```

启动服务：

```bash
npm run dev
```

验证结果：

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


Next.js - API Routes


> `useRef` 返回一个可变的 `ref` 对象，其 `.current` 属性被初始化为传入的参数（initialValue），返回的 `ref` 对象在组件的整个生命周期内保持不变。

例如：创建`VideoPlayer`组件

```tsx
import {useRef} from 'react'
import VideoPlayer from 'videoplayer'

function VideoPlayerComponent() {
  const playerRef = useRef(new VideoPlayer())
  //
}
```

对于上面的代码，在初始化组件时，调用`new VideoPlayer()`的结果将存储在`ref`中，在下一次渲染时，仍将调用`new VideoPlayer()`，但是`useef`不会再接收到其调用结果，这意味着`playerRef`可能为空。

同样的，`useState`也是存在这种情况，区别在于，`useState`可以接受初始化函数，比如

```tsx
import {useState} from 'react'
import VideoPlayer from 'videoplayer'
function VideoPlayerComponent() {
  const [player] = useState(() => new VideoPlayer())
  //
}
```

所以，在使用`playerRef`的时候，需要对它做个判断：

```tsx
import {useRef} from 'react'
import VideoPlayer from 'videoplayer'

function VideoPlayerComponent() {
  const playerRef = useRef<VideoPlayer | null>(null)

  if (playerRef.current === null) {
    playerRef.current = new VideoPlayer()
  }

  const onClick = () => {
    // Error: Object is possibly 'null'.
    playerRef.current.play()
  }
}
```

组件只会调用一次`new VideoPlayer()`并存储在`playerRef`中，但是 typescript 会检查并提示`Error: Object is possibly 'null'`

解决方法：

operation chaining - 可选链

`playerRef.current.play()` => `playerRef.current？.play()`

useImmutableRefValue

```tsx
import {useMemo, useRef} from 'react'

const useImmutableRefValue = <R,>(createRef: () => R) => {
  const ref = useRef<R>()

  const value = useMemo(() => {
    if (!ref.current) {
      ref.current = createRef()
    }

    return ref.current
    // Only one instance, no deps required.
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [])

  return value
}

export default useImmutableRefValue
```

```tsx
import VideoPlayer from 'videoplayer'
import useImmutableRefValue from 'useImmutableRefValue'

function Component() {
  const player = useImmutableRefValue(() => new VideoPlayer())

  const onClick = () => {
    player.play()
  }
}
```


useRef 返回一个可变的 ref 对象，其 .current 属性被初始化为传入的参数（initialValue），返回的 ref 对象在组件的整个生命周期内保持不变。