Nodejs 相关知识

Nodejs是一个js运行环境，可以让js开发后端程序，实现几乎其他后端语言实现的所有功能，能够让js与其他后端语言平起平坐。

nodejs是基于v8引擎，v8是Google发布的开源js引擎，本身就是用于chrome浏览器的js解释部分，现在把v8转移到服务器上，用于做服务器端的软件。

Nodejs超强的高并发能力，能够实现高性能服务器

node环境：

只有v8引擎解析js，没有dom和bom对象。

浏览器环境：

Blink：起到排版作用，对html/css进行解析，确定每个元素位置

V8：解析js

CommonJS规范

我们可以把公共功能抽离成一个单独的js文件作为一个模块，默认情况下这个里面的方法或者属性，外面是没法访问的，如果要外部可以访问模块里的方法或者属性，就必须在模块里面通过exports 或者 module.exports 暴露属性或者方法。

module.exports = {test,a}

module.exports = test

//可以一个一个的多个导出
exports.test = test 
exports.a = a

const a = require('./test.js')

npm

npm init

npm install/i -g

npm install/i --save -dev

npm list -g（列举目录下的安装包）

npm info 包名

npm i/install md5@1（指定安装版本）

npm outdated（检查包是否已过时）

--save：添加在dependencies

-dev/-D：添加在devDependencies

-g：全局安装

依赖版本前的符号：

'^2.1.0' ：^表示会安装 2.*.* 的最新版本

'~2.1.0' ：^表示会安装 2.1.* 的最新版本

'*' ：^表示会安装最新版本

nrm

nrm是npm的镜像源管理工具，国外资源太慢，可以使用这个在npm源间切换，手动切换：

npm config set registry https://registry.npm.taobao.org

 全局安装 nrm

npm i -g nrm

使用nrm

执行命令nrm ls 查看可选源 ，其中带有 * 的是当前使用源，上面的输出表明是官方源。

切换nrm

切到taobao源：

npm use taobao

测试速度 

测试相应源的响应时间

nrm test

查看当前的仓库 

npm config get registry

 中国npm镜像

这是一个完整的npmjs.org镜像，你可以用此代替官方版本（只读），同步频率目前为10分钟一次与官方服务同步，之后可以使用 cnpm 下载。

npm i -g cnpm --registry=https://registry.npmmirror.com

yarn 

npm install -g yarn

比npm快，yarn 缓存每个下载过的包，所以再次使用无须重复下载，同时利用并行下载以最大化资源利用率，因此安装速度更快。

安全性：执行代码前，yarn 会通过算法检验每个安装包的完整性。

开始新项目：yarn init

添加依赖：yarn add 包名 |  yarn add 包名@版本 | yarn add 包名 --dev

升级依赖包：yarn upgrade 包名@版本

移除依赖包：yarn remove 包名

安装全部依赖：yarn install

 ES模块化写法

在package.json中加入type选项，即可使用es的模块化写法。

npm init 

{
  "name": "aaa",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "type": "module",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "jerry",
  "license": "ISC"
}

//暴露出 引入
export default obj => import obj from './1.js'

export const demo = 'hello' => import { demo } from './2/js'

 内置模块

http模块

创建服务器，node app.js 启动服务器

全局安装 nodemon 自动重启（node-dev也可以）

npm i -g nodemon / npm i -g node-dev 

启动服务器：

nodemon app.js 

const http = require('http')
console.log(http);

const server = http.createServer((req, res) => {

    res.writeHead(200, { 'content-type': 'application/json;charset=utf-8' });
    //通过访问不同的url发送不同的数据
    res.end(JSON.stringify(render(req.url)))
})

server.listen(8000, () => {
    console.log('start');
})
function render(url) {
    switch (url) {
        case '/home':

            return { data: 'home' }

        case '/about':
            return {
                data: 'about'
            }
        default:
            return 'index'
    }
}

JsonP 

解决跨域的办法之一，后端直接返回一个函数，并且执行，前提是在html文件有已经定义好的函数，前后端保持一致。

const http = require('http')
const url = require('url')

const server = http.createServer((req, res) => {

    res.writeHead(200, { 'content-type': 'application/json;charset=utf-8' });
    //通过访问不同的url发送不同的数据
    const {pathname,query} = url.parse(req.url,true) //http://localhost:8000/home?callback=test2
    res.end(`${query.callback}(${JSON.stringify(render(pathname))})`)
})

server.listen(8000, () => {
    console.log('start');
})

function render(url) {
    switch (url) {
        case '/home':

            return { data: 'home' }

        case '/about':
            return {
                data: 'about'
            }
        default:
            return 'index'
    }
}

 cors

添加cors头，解决跨域

const http = require('http')
const url = require('url')

const server = http.createServer((req, res) => {

    res.writeHead(200, { 'content-type': 'application/json;charset=utf-8', 'access-control-allow-origin': '*' });
    //通过访问不同的url发送不同的数据
    const { pathname, query } = url.parse(req.url, true) //http://localhost:8000/home
    console.log(query);
    res.end(JSON.stringify(render(pathname)))
})

server.listen(8000, () => {
    console.log('start');
})

function render(url) {
    switch (url) {
        case '/home':

            return { data: 'home' }

        case '/about':
            return {
                data: 'about'
            }
        default:
            return 'index'
    }
}

 get

http既可以做服务端，也可以做客户端，可以解决跨域成为代理服务

const http = require('http')
const https = require('https')
const url = require('url')

const server = http.createServer((req, res) => {

    res.writeHead(200, { 'content-type': 'application/json;charset=utf-8', 'access-control-allow-origin': '*' });
    //通过访问不同的url发送不同的数据
    const { pathname, query } = url.parse(req.url, true) //http://localhost:8000/home
    switch (pathname) {
        case '/home':
            httpget((data)=>{
                res.end(data)
            })
        case '/about':
            return {
                data: 'about'
            }
        default:
            return 'index'
    }
})

server.listen(8000, () => {
    console.log('start');
})


function httpget(callback){
    let data = ''
    //https://api.douban.com/v2/movie/in_theaters
    https.get('https://i.maoyan.com/api/mmdb/movie/v3/list/hot.json',res=>{
        res.on('data',chunk=>{
            data+=chunk
        })
        res.on('end',()=>{
            callback(data)
        })
    })
}

 post

const http = require('http')
const https = require('https')
const url = require('url')

const server = http.createServer((req, res) => {

    res.writeHead(200, { 'content-type': 'application/json;charset=utf-8', 'access-control-allow-origin': '*' });
    //通过访问不同的url发送不同的数据
    const { pathname, query } = url.parse(req.url, true) //http://localhost:8000/home
    switch (pathname) {
        case '/home':
            httppost((data)=>{
                res.end(data)
            })
        case '/about':
            return {
                data: 'about'
            }
        default:
            return 'index'
    }
})

server.listen(8000, () => {
    console.log('start');
})


function httppost(callback){
    let data = ''
    //'https://m.xiaomiyoupin.com/mtop/market/search/placeHolder'
    //请求的信息
    let options={
        hostname:'m.xiaomiyoupin.com',
        port:"443",
        path:"/mtop/market/search/placeHolder",
        method: "POST",
        headers:{
            'Content-Type':"application/json"
            //'Content-Type':"x-www-form-urlencoded" 这种对应传参req.write("name=zhangsan&age=6")
        }
    }
    let req = https.request(options,res=>{
        res.on('data',chunk=>{
            data+=chunk
        })
        res.on('end',()=>{
            callback(data)
        })
    })
    req.write(JSON.stringify([{},{"baseParam":{"ypClient":1}}]))
    req.end()
}

爬虫 

可以直接爬出网页，调用接口，可以拿到网页的html结构数据。然后通过过滤出有效的信息返回给前端。需要工具 cheerio，用法类似于jQuery

npm i --save cheerio

const http = require('http')
const https = require('https')
const url = require('url')
const cheerio = require('cheerio')

const server = http.createServer((req, res) => {

    res.writeHead(200, { 'content-type': 'application/json;charset=utf-8', 'access-control-allow-origin': '*' });
    //通过访问不同的url发送不同的数据
    const { pathname, query } = url.parse(req.url, true) //http://localhost:8000/home
    switch (pathname) {
        case '/home':
            httpget((data) => {
                res.end(spider(data))
            })
        case '/about':
            return {
                data: 'about'
            }
        default:
            return 'index'
    }
})

server.listen(8000, () => {
    console.log('start');
})


function httpget(callback) {
    let data = ''
    //https://api.douban.com/v2/movie/in_theaters
    https.get('https://i.maoyan.com/?requestCode=32779c7926dc56716d208cc297ee8da1z5u0y', res => {
        res.on('data', chunk => {
            data += chunk
        })
        res.on('end', () => {
            callback(data)
        })
    })
}

function spider(data) {
    let $ = cheerio.load(data)
    //通过选择器来定位到元素
    let $movielist = $(".column.content")
    let movies = []
    $movielist.each((index, value) => {
        movies.push({ title: $(value).find('.title').text(), grade: $(value).find('.grade').text(),actor:  $(value).find('.actor').text()})
    })
    console.log($movielist);
    console.log(movies);
    return JSON.stringify(data)
}

url模块

parse和format（旧版）：

parse：在使用查询字符串的方式请求时，可以用来解析带有查询字符串的请求。两个参数：url：传入的url，第二个是否将参数解析为对象格式，默认是false，pathname是对应的url，query是请求的请求参数对象。

format：与parse正好相对立，将url.parse解析的对象转为对应的url地址

const http = require('http')
const url = require('url')

const server = http.createServer((req, res) => {

    res.writeHead(200, { 'content-type': 'application/json;charset=utf-8' });
    //通过访问不同的url发送不同的数据
    //   {
    //     protocol: null,
    //     slashes: null,
    //     auth: null,
    //     host: null,
    //     port: null,
    //     hostname: null,
    //     hash: null,
    //     search: '?a=1&b=2',
    //     query: [Object: null prototype] { a: '1', b: '2' },
    //     pathname: '/home',
    //     path: '/home?a=1&b=2',
    //     href: '/home?a=1&b=2'
    //   }
    const {pathname,query} = url.parse(req.url,true) //http://localhost:8000/home?a=1&b=2
    console.log(url.format(url.parse(req.url,true))); //格式化为url地址
    res.end(JSON.stringify(render(pathname)))
})

server.listen(8000, () => {
    console.log('start');
})

function render(url) {
    switch (url) {
        case '/home':

            return { data: 'home' }

        case '/about':
            return {
                data: 'about'
            }
        default:
            return 'index'
    }
}

resolve （旧版）

用于拼接url

const url = require('url')
let a = url.resolve('1/2/3/','4') // '1/2/3/4'
let b = url.resolve('1/2/3','4') // '1/2/4'

let c = url.resolve('http://baidu.com/','/4') // 'http://baidu.com/4'域名后的所有都被替换
let d = url.resolve('http://baidu.com/1','/4') //'http://baidu.com/4'

URL对象（新）

也是用于获取请求的url地址以及参数

const http = require('http')
const url = require('url')

const server = http.createServer((req, res) => {

    res.writeHead(200, { 'content-type': 'application/json;charset=utf-8' });
    //通过访问不同的url发送不同的数据
    const myURL = new URL(req.url,'http://127.0.0.1:3000') //第二个参数必填，合法地址，这里取本地，因为这里请求的是本地
    console.log(myURL);
    // {
    //     href: 'http://127.0.0.1:3000/home?a=1&b=2',
    //     origin: 'http://127.0.0.1:3000',
    //     protocol: 'http:',
    //     username: '',
    //     password: '',
    //     host: '127.0.0.1:3000',
    //     hostname: '127.0.0.1',
    //     port: '3000',
    //     pathname: '/home',
    //     search: '?a=1&b=2',
    //     searchParams: URLSearchParams { 'a' => '1', 'b' => '2' },
    //     hash: ''
    //   }
    const pathname = myURL.pathname
    res.end(JSON.stringify(render(pathname)))
})

server.listen(8000, () => {
    console.log('start');
})

function render(url) {
    switch (url) {
        case '/home':

            return { data: 'home' }

        case '/about':
            return {
                data: 'about'
            }
        default:
            return 'index'
    }
}

URLSearchParams类

提供对 URL 查询的读写访问，在全局对象上也可用，WHATWG URLSearchParams 接口和querystring 模块有相似的用途，但querystring模块用途更广，因为它允许自定义的分隔符（& 和 =），此api纯粹是为网址查询字符串设计的。

    const myURL = new URL("https://example.org/?abc=123")
    console.log(myURL.searchParams.get('abc')); //123

    myURL.searchParams.append('www','xyz')
    console.log(myURL.href); //"https://example.org/?abc=123&www=xyz"

    myURL.searchParams.delete('abc')
    myURL.searchParams.set('a','b')
    console.log(myURL.href) //"https://example.org/?a=b"

    const newSearchParams = new URLSearchParams(myURL.searchParams)
    console.log(newSearchParams); // { 'www' => 'xyz', 'a' => 'b' }

    newSearchParams.append('a','c')
    console.log(myURL.href); //https://example.org/?a=b
    console.log(newSearchParams.toString());//www=xyz&a=b&a=c

拼接作用：

 let b = new URL('one',"https://example.org/?abc=123")
 console.log(b.href); //https://example.org/one

详情参考：URL | Node.js v19 API

format（新）

参数：

url：WHATWG 网址对象

options：auth 如果序列化的网址字符串包含用户名和密码，则为true，否则为false，默认值：true。

fragment：如果序列化的网址字符串包含片段，则为true，否则为false，默认值：true。

search：如果序列化的网址字符串包含搜索查询，则为true，否则为false，默认值：true。

unicode：如果序列化的网址字符串的主机组件中的unicode字符应该被直接编码而不是Punycode编码，默认值：false。

返回值

返回 WHATWG 网址 对象的网址 String 表示的可自定义的序列化。

网址对象具有 toString方法和href属性，用于返回网址的字符串序列化。但是这些都不能以任何方式自定义。url.format(url,[options])方法允许对输出进行基本的自定义。

    const myURL = new URL("https://a:b@测试?abc#foo")
    console.log(url.format(myURL));//https://a:b@xn--0zwm56d/?abc#foo 编译了unicode码
    console.log(url.format(myURL,{unicode:true}));//https://a:b@测试/?abc#foo 保持unicode码
    console.log(url.format(myURL,{unicode:true,auth:false}));//https://测试/?abc#foo 去除了a:b
    console.log(url.format(myURL,{unicode:true,fragment:false}));//https://a:b@测试/?abc 去除了#后面的内容
    console.log(url.format(myURL,{unicode:true,search:false}));//https://a:b@测试/#foo 去除了?后面的内容到#结束

url.fileURLToPath(url) 和 url.pathToFileURL(path)

url.fileURLToPath(url)  新增于10.12

参数：url： | 要转换为路径的文件网址字符串或网址对象，必须绝对路径

返回： 完全解析的特定于平台的node.js文件路径。

此函数可确保正确解码宝粉笔编码字符，并确保跨平台有效的绝对路径字符串。

 new URL的方式对于文件路径是有问题的，所以采用fileURLToPath。

    console.log(url.fileURLToPath('file:///C:/path/')) // /C:/path/
    console.log(new URL('file:///C:/path/').pathname) // /C:/path/

    console.log(url.fileURLToPath('file://nas/foo.txt')) // //nas//foo.txt(Windows)
    console.log(new URL('file://nas/foo.txt').pathname) // /foo.txt

    console.log(url.fileURLToPath('file:///你好.txt')) // /你好.txt(POSIX)
    console.log(new URL('file:///你好.txt').pathname) // /%E4%BD%A0%E5%A5%BD.txt

    console.log(url.fileURLToPath('file:///hello world')) // /hello world (POSIX)
    console.log(new URL('file:///hello world').pathname) // /hello%20worldconst _

 url.pathToFileURL(path) 新增于10.12

参数：path 要转为文件网址的路径

返回： 文件网址对象

该函数确保path被绝对解析，并且在转换为文件网址时正确编码网址控制字符。

import {pathToFileURL} from 'url'

new URL('/foo#1','file')  //错误：file:///foo#1
pathToFileURL('/foo#1')   //正确：file:///foo%231(POSIX)

new URL('/some/path%.c','file')  //错误：file:///some/path%.c
pathToFileURL('/some/path%.c')   //正确：file:///some/path%25.c(POSIX)

 url.urlToHttpOptions(url)

参数：url 要转换为选项对象的 WHATWG对象。

返回：