node.js养成计划（一）入门一二三事_node.js工程师养成计划

为什么要学习node

一、什么是node.js

• Node.js 是什么
  
  • Node.js是一个JavaScript 运行时环境，可以解析和执行js代码
  • 既不是语言，也不是框架，它是一个平台
  • 它使js可以脱离浏览器运行
• Node.js 中的 JavaScript
  • 没有 BOM、DOM
  • EcmaScript 基本的 JavaScript 语言部分
  • 在 Node 中为 JavaScript 提供了一些服务器级别的 API
    • 文件操作的能力
    • http 服务的能力（网络构建的能力）
• Node.js使用npm安装库文件

二、node能做什么

• node只是我们学习BS模型的一个工具
• web服务器后台
• 命令行工具
  • npm
  • git
  • hexo
  • …
• 前端接触最多的是他的命令行工具
  • 主要使用第三方库
  • webpack
  • gulp
  • npm
• 模块化编程
  • RequirJS
  • SeaJS
  • …
• 异步编程
  • 回调函数
  • Promise
  • async
  • generator
• Express Web 开发框架
• Ecmascript 6
  • 他只是语法而已
• 学习Node不仅会帮助大家打开服务端黑盒子，。有助于学习高阶知识
  • vue
  • React
  • angular

三、安装node.js

1. 首先查看是否安装了Node

node --version  或  node -v
1

2.一路傻瓜式next安装即可

3.确认安装是否成功

node --version  或  node -v   或  node 进入交互
1

4.别急还没安装完 – 继续往下走

并不是说NodeJS和NPM安装好了以后就能直接使用了。因为默认情况下，NPM安装的模块并不会安装到NodeJS的程序目录，而是C盘，我们要想办法去改变他的路径到D:\nodejs\目录。

• 第一步修改NPM的缓存目录和全局目录路径，将对应的模块目录改到D盘nodejs的安装目录

D盘nodejs目录下创建两个目录，分别是node_cache和node_global，
这是用来放安装过程的缓存文件以及最终的模块配置位置。配置完成
后，在cmd执行下面这两个命令： 
npm config set prefix “D:\nodejs\node_global”   //配置全局模块存放路径
npm config set cache “D:\nodejs\node_cache”   //cache路径

1
2
3
4
5
6

• 第二步是配置npm和nodejs的环境变量，这样nodejs才能正确地调用对应的模块。
  在环境变量的配置界面配置NODE_PATH，值填D:\nodejs\node_global\node_modules
  

还需要修改一些nodejs默认的模块调用路径，因为模块的安装位置变了，如果nodejs的命令还到原来的位置去找，肯定是找不到安装的模块了。选择Path，然后点击编辑，然后选择npm那个，修改成D:\nodejs\node_global\。

重置npm模块的注册、管理、发布地址为cnpm：

    npm install cnpm -g（引申：cnpmjs.org: Private npm registry and web for Company，cnpm是一个网站，同时cnpm也是一个命令行工具，面向企业级的私有npm包的注册地、管理、发布）

重置模块的镜像地址：

    修改npm包管理器的registry为淘宝镜像，npm config set registry https://registry.npm.taobao.org（官方地址为registry.npmjs.org）
重置设置代理：npm config set proxy http://server:port
1
2
3
4
5
6
7
8

4.npm命令

• 全局命令

  • 卸载全局安装模块 npm uninstall -g xxx
  • 安装 npm install xxx -g
  • 查看全局安装过的包 npm list -g --depth 0
  • …

• 其他命令

  • npm install moduleName 命令
  1. 安装模块到项目node_modules目录下。
  2. 不会将模块依赖写入devDependencies或dependencies 节点。
  3. 运行 npm install 初始化项目时不会下载模块。
  • npm install -g moduleName 命令
  1. 安装模块到全局，不会在项目node_modules目录中保存模块包。
  2. 不会将模块依赖写入devDependencies或dependencies 节点。
  3. 运行 npm install 初始化项目时不会下载模块。
  • npm install -save moduleName 命令
  1. 安装模块到项目node_modules目录下。
  2. 会将模块依赖写入dependencies 节点。
  3. 运行 npm install 初始化项目时，会将模块下载到项目目录下。
  4. 运行npm install --production或者注明NODE_ENV变量值为production时，会自动下载模块到node_modules目录中。
  • npm install -save-dev moduleName 命令
  1. 安装模块到项目node_modules目录下。
  2. 会将模块依赖写入devDependencies 节点。
  3. 运行 npm install 初始化项目时，会将模块下载到项目目录下。
  4. 运行npm install --production或者注明NODE_ENV变量值为production时，不会自动下载模块到node_modules目录中。

总结
devDependencies 节点下的模块是我们在开发时需要用的，比如项目中使用的 gulp ，压缩css、js的模块。这些模块在我们的项目部署后是不需要的，所以我们可以使用 -save-dev 的形式安装。像 express 这些模块是项目运行必备的，应该安装在 dependencies 节点下，所以我们应该使用 -save 的形式安装。

四、在 Node 中为 JavaScript 提供了一些服务器级别的 API

（一）文件读写

浏览器中的JavaScript没有文件操作能力的，但是node中的JavaScript具有文件操作能力.
node中想要进行文件操作，就需要引入fs这个模块，提供了所有的文件操作相关API ；fs是file-system（文件系统）的简写.

• 1.使用require方法加在fs核心模块

/ 浏览器中的 JavaScript 是没有文件操作的能力的
// 但是 Node 中的 JavaScript 具有文件操作的能力

// fs 是 file-system 的简写，就是文件系统的意思
// 在 Node 中如果想要进行文件操作，就必须引入 fs 这个核心模块
// 在 fs 这个核心模块中，就提供了所有的文件操作相关的 API
// 例如：fs.readFile 就是用来读取文件的

// 1. 使用 require 方法加载 fs 核心模块
var fs = require('fs')

// 2. 读取文件
//    第一个参数就是要读取的文件路径
//    第二个参数是一个回调函数
//          
//        成功
//          data 数据
//          error null
//        失败
//          data undefined没有数据
//          error 错误对象
fs.readFile('./data/hello.txt', function (error, data) {
  // <Buffer 68 65 6c 6c 6f 20 6e 6f 64 65 6a 73 0d 0a>
  // 文件中存储的其实都是二进制数据 0 1
  // 这里为什么看到的不是 0 和 1 呢？原因是二进制转为 16 进制了
  // 但是无论是二进制01还是16进制，人类都不认识
  // 所以我们可以通过 toString 方法把其转为我们能认识的字符
  // console.log(data)

  // console.log(error)
  // console.log(data)

  // 在这里就可以通过判断 error 来确认是否有错误发生
  if (error) {
    console.log('读取文件失败了')
  } else {
    console.log(data.toString())
  }
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

• 2.写入文件

var fs = require('fs')

// $.ajax({
//   ...
//   success: function (data) {
    
//   }
// })

// 第一个参数：文件路径
// 第二个参数：文件内容
// 第三个参数：回调函数
//    error
//    
//    成功：
//      文件写入成功
//      error 是 null
//    失败：
//      文件写入失败
//      error 就是错误对象
fs.writeFile('./data/你好.md', '大家好，给大家介绍一下，我是Node.js', function (error) {
  // console.log('文件写入成功')
  // console.log(error)
  if (error) {
    console.log('写入失败')
  } else {
    console.log('写入成功了')
  }
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

（二）http服务

• http
  • require
  • 端口号
    • ip 地址定位计算机
    • 端口号定位具体的应用程序
  • Content-Type
    • 服务器最好把每次响应的数据是什么内容类型都告诉客户端，而且要正确的告诉
    • 不同的资源对应的 Content-Type 是不一样，具体参照：http://tool.oschina.net/commons
    • 对于文本类型的数据，最好都加上编码，目的是为了防止中文解析乱码问题
  • 通过网络发送文件
    • 发送的并不是文件，本质上来讲发送是文件的内容
    • 当浏览器收到服务器响应内容之后，就会根据你的 Content-Type 进行对应的解析处理

// 接下来，我们要干一件使用 Node 很有成就感的一件事儿
// 你可以使用 Node 非常轻松的构建一个 Web 服务器
// 在 Node 中专门提供了一个核心模块：http
// http 这个模块的职责就是帮你创建编写服务器的

// 1. 加载 http 核心模块
var http = require('http')

// 2. 使用 http.createServer() 方法创建一个 Web 服务器
//    返回一个 Server 实例
var server = http.createServer()

// 3. 服务器要干嘛？
//    提供服务：对 数据的服务
//    发请求
//    接收请求
//    处理请求
//    给个反馈（发送响应）
//    注册 request 请求事件
//    当客户端请求过来，就会自动触发服务器的 request 请求事件，然后执行第二个参数：回调处理函数
/ request 请求事件处理函数，需要接收两个参数：
//    Request 请求对象
//        请求对象可以用来获取客户端的一些请求信息，例如请求路径
//    Response 响应对象
//        响应对象可以用来给客户端发送响应消息
server.on('request', function (request, response) {
  // http://127.0.0.1:3000/ /
  // http://127.0.0.1:3000/a /a
  // http://127.0.0.1:3000/foo/b /foo/b
  console.log('收到客户端的请求了，请求路径是：' + request.url)

  // response 对象有一个方法：write 可以用来给客户端发送响应数据
  // write 可以使用多次，但是最后一定要使用 end 来结束响应，否则客户端会一直等待
  response.write('hello')
  response.write(' nodejs')

  // 告诉客户端，我的话说完了，你可以呈递给用户了
  response.end()

  // 由于现在我们的服务器的能力还非常的弱，无论是什么请求，都只能响应 hello nodejs
  // 思考：
  //  我希望当请求不同的路径的时候响应不同的结果
  //  例如：
  //  / index
  //  /login 登陆
  //  /register 注册
  //  /haha 哈哈哈
})


// 4. 绑定端口号，启动服务器
server.listen(3000, function () {
  console.log('服务器启动成功了，可以通过 http://127.0.0.1:3000/ 来进行访问')
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

var http = require('http')

// 1. 创建 Server
var server = http.createServer()

// 2. 监听 request 请求事件，设置请求处理函数
server.on('request', function (req, res) {
  console.log('收到请求了，请求路径是：' + req.url)
  console.log('请求我的客户端的地址是：', req.socket.remoteAddress, req.socket.remotePort)

  // res.write('hello')
  // res.write(' world')
  // res.end()

  // 上面的方式比较麻烦，推荐使用更简单的方式，直接 end 的同时发送响应数据
  // res.end('hello nodejs')

  // 根据不同的请求路径发送不同的响应结果
  // 1. 获取请求路径
  //    req.url 获取到的是端口号之后的那一部分路径
  //    也就是说所有的 url 都是以 / 开头的
  // 2. 判断路径处理响应

  var url = req.url

  if (url === '/') {
    res.end('index page')
  } else if (url === '/login') {
    res.end('login page')
  } else if (url === '/products') {
    var products = [{
        name: '苹果 X',
        price: 8888
      },
      {
        name: '菠萝 X',
        price: 5000
      },
      {
        name: '小辣椒 X',
        price: 1999
      }
    ]

    // 响应内容只能是二进制数据或者字符串
    //  数字
    //  对象
    //  数组
    //  布尔值
    res.end(JSON.stringify(products))
  } else {
    res.end('404 Not Found.')
  }
})

// 3. 绑定端口号，启动服务
server.listen(3000, function () {
  console.log('服务器启动成功，可以访问了。。。')
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

五、node中的js和js

• EcmaScript
  • 没有DOM、BOM
• 核心模块
• 第三方模块
• 用户自定义模块

（一）核心模块

node 为js提供了很多服务器级别的API,这些API绝大多数被包装到了一个具名的核心模块中；如 fs 核心模块， http 服务构建的 http 模块、os 操作系统信息模块。。。

• node中，模块有三种：
  • 具名的核心模块，如 fs、http等
    • fs = require(‘fs’) // 映入外部的模块
      • require 方法有两个作用：
      1. 加载文件模块并执行里面的代码
      2. 拿到被加载文件模块导出的接口对象
  • 用户自己编写的文件模块
    • require(’./xx/myjs.js’) 可以省略 .js 后缀
  • 在node中没有全局作用域；只有模块作用域
    • 内部不能访问外部，外部不能访问内部，那模块间怎么通信？？
      • 在每个文件模块中都提供了一个对象：exports
      • exports 默认是一个空对象
      • 你要做的就是把所有需要被外部访问的成员挂载到这个 exports 对象中

var foo = 'bbb'

// console.log(exports)

exports.foo = 'hello'

exports.add = function (x, y) {
  return x + y
}

exports.readFile = function (path, callback) {
  console.log('文件路径：', path)
}
exports.age = age

var age = 18


function add(x, y) {
  return x - y
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这样就可以调用了

var bExports = require('./b')
var fs = require('fs')

console.log(bExports.foo)

console.log(bExports.add(10, 30))

console.log(bExports.age)

bExports.readFile('./a.js')

fs.readFile('./a.js', function (err, data) {
  if (err) {
    console.log('读取文件失败')
  } else {
    console.log(data.toString())
  }
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18