安装nvm和nodejs


`Node.js`提供了一个`fs`模块，用于操作文件系统。通过`fs`模块，可以读取文件，创建文件，删除文件，移动文件，复制文件等。

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

## sync 和 async

`fs`模块中的每个方法都有`sync`和`async`两种形式。异步方法会返回一个`Promise`对象，而同步方法会返回一个`callback`。

```bash
echo "hello world" > demo.txt
```

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

// 异步读取文件
fs.readFile('demo.txt', function (err, data) {
  if (err) {
    return console.error(err)
  }
  console.log('Asynchronous read: ' + data.toString())
})

// 同步读取文件
var data = fs.readFileSync('demo.txt')
console.log('Synchronous read: ' + data.toString())

console.log('Program Ended')
```

## 打开文件

语法：`fs.open(path, flags, [mode], callback)`

- `path`: 文件路径
- `flags`: 打开文件的方式，可以是`r`，`r+`，`w`，`w+`，`a`，`a+`，`x`，`x+`，`t`，`t+`，`c`，`c+`
- `mode`: 打开文件的模式，默认是`0o666`
- `callback`: 回调函数，参数为 err,fd

```js
const fs = require('fs')
fs.open('demo.txt', 'r', function (err, fd) {
  if (err) {
    return console.error(err)
  }
  console.log('文件打开成功，文件描述符：' + fd)
})
```

## 获取文件信息

语法：`fs.stat(path, callback)`

- `path`: 文件路径
- `callback`: 回调函数，参数为 err,stats

方法：

- `stats.isFile()`: 判断是否是文件
- `stats.isDirectory()`: 判断是否是目录
- `stats.isBlockDevice()`: 判断是否是块设备
- `stats.isCharacterDevice()`: 判断是否是字符设备
- `stats.isSymbolicLink()`: 判断是否是符号链接
- `stats.isFIFO()`: 判断是否是 FIFO，如果是 FIFO，则返回 true，否则返回 false
- `stats.isSocket()`: 判断是否是 Socket

```js
const fs = require('fs')
fs.stat('demo.txt', function (err, stats) {
  if (err) {
    return console.error(err)
  }
  console.log(stats)
  console.log('文件类型：' + stats.isFile())
  console.log('文件大小：' + stats.size)
  console.log('文件创建时间：' + stats.birthtime)
})
```

## 写入文件

语法：`fs.writeFile(file, data, [options], callback)`

- `file`: 文件路径
- `data`: 写入的数据
- `options`: 可选参数，可以是`encoding`，`mode`，`flag`
- `callback`: 回调函数，参数为 err

```js
const fs = require('fs')
fs.writeFile('demo.txt', '我是写入的文件内容', function (err) {
  if (err) {
    return console.error(err)
  }
  console.log('数据写入成功！')
  console.log('--------我是分割线-------------')
  console.log('读取写入的数据！')
  fs.readFile('demo.txt', function (err, data) {
    if (err) {
      return console.error(err)
    }
    console.log('异步读取文件数据: ' + data.toString())
  })
})
```

## 读取文件

语法：`fs.read(fd, buffer, offset, length, position, callback)`

- `fd`：返回的文件描述符
- `buffer`：数据被写入的缓冲区
- `offset`：缓冲区写入的偏移位置
- `length`：读取的字节数
- `position`：从哪里开始读取
- `callback`：`err`、`bytesRead`、`buffer`

```js
var fs = require('fs')
var buf = new Buffer(1024)

console.log('Going to open an existing file')
fs.open('input.txt', 'r+', function (err, fd) {
  if (err) {
    return console.error(err)
  }
  console.log('File opened successfully!')
  console.log('Going to read the file')

  fs.read(fd, buf, 0, buf.length, 0, function (err, bytes) {
    if (err) {
      console.log(err)
    }
    console.log(bytes + ' bytes read')

    // Print only read bytes to avoid junk.
    if (bytes > 0) {
      console.log(buf.slice(0, bytes).toString())
    }
  })
})
```

## 关闭文件

语法：`fs.close(fd, callback)`

- `fd`：返回的文件描述符
- `callback`：回调函数，参数为 err

```js
const fs = require('fs')
fs.open('demo.txt', 'r', function (err, fd) {
  if (err) {
    return console.error(err)
  }
  console.log('文件打开成功，文件描述符：' + fd)
  fs.close(fd, function (err) {
    if (err) {
      return console.error(err)
    }
    console.log('文件关闭成功！')
  })
})
```

## 删除文件

语法：`fs.unlink(path, callback)`

- `path`：文件路径
- `callback`：回调函数，参数为 err

```js
const fs = require('fs')
fs.unlink('demo.txt', function (err) {
  if (err) {
    return console.error(err)
  }
  console.log('文件删除成功！')
})
```

## 创建目录

语法：`fs.mkdir(path, [mode], callback)`

- `path`：目录路径
- `mode`：目录权限
- `callback`：回调函数，参数为 err

```js
const fs = require('fs')
fs.mkdir('/tmp/test', function (err) {
  if (err) {
    return console.error(err)
  }
  console.log('目录创建成功！')
})
```

## 读取目录

语法：`fs.readdir(path, callback)`

- `path`：目录路径
- `callback`：回调函数，参数为 err、files

```js
const fs = require('fs')
fs.readdir('/tmp', function (err, files) {
  if (err) {
    return console.error(err)
  }
  files.forEach(function (file) {
    console.log(file)
  })
})
```

## 阅读目录

语法：`fs.readdirSync(path)`

- `path`：目录路径

```js
const fs = require('fs')
fs.readdirSync('/tmp')
```

## 删除目录

语法：`fs.rmdir(path, callback)`

- `path`：目录路径
- `callback`：回调函数，参数为 err

```js
const fs = require('fs')
fs.rmdir('/tmp/test', function (err) {
  if (err) {
    return console.error(err)
  }
  console.log('目录删除成功！')
})
```

[入门教程](http://nodejs.cn/learn/the-nodejs-fs-module)
[Node.js 文档](http://nodejs.cn/api/buffer.html)


File System是一个文件系统模块，用于操作文件系统。

Node.js - File System


在 Next.js 中，可以创建动态路由。比如：

- `[id].js`，表示 id 为相对路径的动态页面
- `lib/posts.js`，表示在 lib 目录下的 post 页面

创建`[id].js`

```jsx
import Link from 'next/link'
import Head from 'next/head'
import Container from '../../components/container'

import {getAllPostIds, getPostData} from '../../lib/posts'

export default function Post({postData}) {
  return (
    <Container>
      {postData.id}
      <br />
      {postData.title}
      <br />
      {postData.date}
    </Container>
  )
}
export async function getStaticPaths() {
  const paths = getAllPostIds()
  return {
    paths,
    fallback: false
  }
}

export async function getStaticProps({params}) {
  const postData = getPostData(params.id)
  return {
    props: {
      postData
    }
  }
}
```

创建`lib/posts.js`

```jsx
export function getPostData(id) {
  const postOne = {
    title: 'One',
    id: 1,
    date: '7/12/2020'
  }

  const postTwo = {
    title: 'Two',
    id: 2,
    date: '7/12/2020'
  }
  if (id == 'one') {
    return postOne
  } else if (id == 'two') {
    return postTwo
  }
}

export function getAllPostIds() {
  return [
    {
      params: {
        id: 'one'
      }
    },
    {
      params: {
        id: 'two'
      }
    }
  ]
}
```

启动服务

```bash
npm run dev
```

验证结果

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


在 Next.js 中，可以创建动态路由

Next.js - Dynamic API Routes


## 语法

```sql
table_name AS alias_name
```

## 作用

假如在查询中，你想要查询一个表的所有数据，但是又不想要表的名字，可以使用别名。

```sql
a_very_long_table_name.column_name

a_very_long_table_name AS alias_name

alias.column_name
```

在`JOIN`语句中使用别名，可以避免重复的表名。

```sql
SELECT
	c.customer_id,
	first_name,
	amount,
	payment_date
FROM
	customer c
INNER JOIN payment p
    ON p.customer_id = c.customer_id
ORDER BY
   payment_date DESC;
```

在`self-join`中使用别名，可以避免重复的表名。

```sql
SELECT
    e.first_name employee,
    m .first_name manager
FROM
    employee e
INNER JOIN employee m
    ON m.employee_id = e.manager_id
ORDER BY manager;
```


Postgresql alias是一种把表名作为别名的方法，它可以让你更好的理解表的含义。

Postgresql - TABLE ALIAS


在 ECMAScript 中，变量可以存在两种类型的值，即原始值和引用值。

1. 原始值占用的内存空间是固定的，而引用值占用的内存空间是动态的。
2. 原始值的值存储在栈中，而引用值的值存储在堆中。
3. 原始值的保存与复制是直接的，而引用值的保存与复制是通过值的拷贝来实现的。
4. 原始值使用`typeof`运算符来检测其类型，而引用值使用`instanceof`运算符来检测其类型。
5. 原始值的值可以通过`==`运算符来比较，而引用值的值可以通过`===`运算符来比较。
6. 使用`new()`构造出的对象是引用值，而不是原始值。

> 除了`null`和`undefined`之外，所有的基本类型都是原始值，而所有的引用类型都是引用值。

## 基本类型

- number
- boolean
- bigint
- string
- symbol
- null
- undefined

## 引用类型

- object
- array
- function

```js
const number = 10

const bool = false

const str = 'Hello!'

const missingObject = null

const nothing = undefined
```

基本类型的值是存储在栈中的，所以在 JavaScript 中，基本类型的值可替换但不可被改变。

```js
var bar = 'baz'
console.log(bar) // baz
bar.toUpperCase()
console.log(bar) // baz

// 使用数组方法可以改变一个数组
var foo = []
console.log(foo) // []
foo.push('plugh')
console.log(foo) // ["plugh"]

// 赋值行为可以给基本类型一个新值，而不是改变它
bar = bar.toUpperCase() // BAZ
```

```js
// 基本类型
let foo = 5

// 定义一个貌似可以改变基本类型值的函数
function addTwo(num) {
  num += 2
}
// 和前面的函数一样
function addTwo_v2(foo) {
  foo += 2
}

// 调用第一个函数，并传入基本类型值作为参数
addTwo(foo)
// Getting the current Primitive value
console.log(foo) // 5

// 尝试调用第二个函数...
addTwo_v2(foo)
console.log(foo) // 5
```

**在执行函数体内语句之前，JavaScript 会将传递进来的参数（基本类型的值）复制一份，创建一个本地副本。这个副本只存在于该函数的作用域中，我们能够通过指定在函数中的标识符访问到它（addTwo 中的 num，addTwo_v2 中的 foo）。**


基本类型与引用类型


LIMIT 语句经常在许多关系型数据库中使用，比如 MySQL，H2，HSQLDB。

但是 LIMIT 语句不属于 SQL 标准。

Postgresql 提供了 SQL 标准的语句来替代 LIMIT，它就是 FETCH 语句，它是在 SQL：2008 标准被提出来的。

## 语法

```sql
OFFSET start { ROW | ROWS }
FETCH { FIRST | NEXT } [ row_count ] { ROW | ROWS } ONLY
```

FIRST 和 NEXT 是同义词，ROW 和 ROWS 是同义词，同义词可以相互替换

start 必须为 0 或正整数，如果没有 OFFSET 字句，则 start 默认为 0，如果 start 比结果集中的行数大，则查询语句不返回结果。

row_count 是大于等于 1 的整数，如果你不指定它，它默认为 1

因为表中存储的行顺序是未指定的，所以应该始终使用 FETCH 子句和 order BY 子句，以使返回结果集中的行顺序一致。

## FETCH vs LIMIT

使用 FETCH 查询并选择第一条记录

```sql
SELECT
    film_id,
    title
FROM
    film
ORDER BY
    title
FETCH FIRST ROW ONLY;
```

![bQ3nfm](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/bQ3nfm.jpg)
等同于以下代码：

```sql
SELECT
    film_id,
    title
FROM
    film
ORDER BY
    title
FETCH FIRST 1 ROW ONLY;
```

## 总结

尽量使用 FETCH 语句，而不是 LIMIT 语句。


如何使用 PostgreSQL FETCH 检索查询返回的部分行

Postgresql - FETCH


`zlib`模块提供通过 `Gzip` 和 `Deflate/Inflate` 实现的压缩功能

## 创建和使用压缩流

```js
const zlib = require('zlib')
const gzip = zlib.createGzip()
const fs = require('fs')
const inp = fs.createReadStream('input.txt')
const out = fs.createWriteStream('input.txt.gz')
inp.pipe(gzip).pipe(out)
// 在桌面创建 input.txt 和 input.txt.gz 文件
```

## 解压缩和创建文件

```js
const zlib = require('zlib')
const gunzip = zlib.createGunzip()
const fs = require('fs')
const inp = fs.createReadStream('input.txt.gz')
const out = fs.createWriteStream('input.txt')
inp.pipe(gunzip).pipe(out)

// 在桌面创建 input.txt 和 input.txt.gz 文件
```

```

```


zlib模块提供通过 Gzip 和 Deflate/Inflate 实现的压缩功能