一. Node概述

1 Node的概念

Node是一个基于Chrome V8引擎的JavaScript代码运行环境

v8引擎
v8引擎是一种js引擎实现, js引擎就是执行js代码的程序或者解释器,所以v8引擎负责解析和执行js代码

运行环境
运行环境就是代码正常运行所需要的环境,Node提供了很多内置对象,比如fs,path,http等,来保证代码的正常运行

  • 浏览器（软件）能够运行JavaScript代码，浏览器就是JavaScript代码的运行环境
  • Node（软件）能够运行JavaScript代码，Node就是JavaScript代码的运行环境

Node作用
可以让js代码开发后台(学习成本比较低)
node支持js,有很多内置对象,可以帮助我们快速的搭建后台

2 Node的组成

① ECMAScript
和js中的基础语法是一样的
② 内置模块

  • fs 文件相关
  • path 路径相关
  • http 服务器相关

③ 第三方模块

  • express 路由,可以快速构建web应用
  • mysql 可以更加方便的操作mysql数据库

    3 Node的安装

    Node官网：https://nodejs.org/en/
    Node中文官网: http://nodejs.cn/
    在官网安装下载
    win+R打开cmd
    Node.js 简介 模块 - 图1
    在cmd中输入node -v查看
    Node.js 简介 模块 - 图2
    输入node, 进入到node的命令行, 执行js代码
    Node.js 简介 模块 - 图3
    按两次ctrl+C退出node命令行

    二. 模块化开发

    1 模块化概念

    模块化: 遵循固定的规范,把一个大文件拆成独立并且相互依赖的多个小模块(把代码进行模块化拆分)

也是一个封装的思想,函数(方法),对代码块的封装,是能在当前文件中复用,不能跨文件使用
可以考虑将代码单独放到一个js文件当中,这样就可以实现跨文件使用,这其实就是模块化思想

好处

  • 提高了代码的复用性
  • 提高了代码的可维护性
  • 可以实现按需加载
  • 便于协同开发

    2 模块化规范

    Node是对CommonJS规范的一种代码实现, 所以在Node中使用的就是CommonJS模块规范
    模块化规范就是对代码进模块化拆分和组合时,需要遵循的规范

导入: require
导出:module.exports

好处
大家都遵循同样的模块化规范来写代码,降低了沟通成本,方便了各个模块之间的相互调用.

3 模块化分类

根据模块来源的不同,分为:

  • 内置模块

    1.         是由node.js官方提供的,例如fs,path,http等

  • 自定义模块

    1.         用户自己创建的每个js文件,都是自定义模块

  • 第三方模块

    1.         是第三方开发出来的,并非官方提供,也不是用户创建的,使用之前需要下载

    4 模块化使用(*)

    1) 定义模块

    模块 每个文件被看成一个单独的模块,模块与模块之间是独立的

如何理解呢?
在一个文件(模块)中定义的变量, 在另一个文件(模块)中无法直接使用

  1. /* 当前这个js文件,就是用户自定义模块 */
  2. console.log('这是我自己写的模块');
  1. const username = '张三'
  3. function sayHello(){
  4.     console.log('大家好,我是'+username);
  5. }

加载自定义模块

  1. require('./01_模块入门_自定义模块书写.js')

2) 导出

如果希望外部能使用当前模块中的变量/函数, 需要使用exports导出

  1. exports是一个对象
  2. 将希望导出的变量/函数挂载到exports对象上, 表示导出

  3. 所谓挂载就是给exports对象添加属性或者方法

    3) 导入(require)

    在Node中导入模块, 需要经历3个步骤

  4. 路径分析

  5. 文件定位
  6. 编译执行

Node中的模块可以分为两类:

  • Node提供的模块, 称为核心模块(内置模块)
  • 用户编写的模块, 称为文件模块(或者: 包package)

    核心模块

对于核心模块的导入, 如fs, http, path等, 直接使用模块名

  1. const fs = require('fs')
  2. const http = require('http')
  3. const path = require('path')

文件模块

5 模块作用域

概念
在自定义模块中,定义的变量,方法等成员,只能在当前模块内被访问,如果想在外面使用,需要导出

好处
防止了全局变量污染问题,而模块的作用域只在当前内部,如果要使用,必须先导出,然后使用者还要用变量接收,就可以避免全局变量污染问题.

全局变量污染问题:
全局变量1

  1. let username='张三'

全局变量2

  1. let username='李四'

变量使用时就可能会出现一些问题

  1. <body>
  2.     <script src="./05_模块作用域_全局变量1.js"></script>
  3.     <script src="./05_模块作用域_全局变量2.js"></script>
  5.     <script>
  6.         console.log(username);
  7.     </script>
  8. </body>

6 模块间共享

module对象

  1. 在每一个js自定义的模块当中,都有一个module对象,它里面存储了和当前模块相关的信息
  1. console.log(module);/* 他是内置的对象,颜色不一样 */
  3. /**
  4.  * 
  5.  Module {
  6.   id: '.',
  7.   path: 'E:\\00_特训营\\day22\\代码',
  8.   exports: {},  //这个属性就是用来导出数据的
  9.   parent: null,
  10.   filename: 'E:\\00_特训营\\day22\\代码\\06_模块间共享_module对象.js',
  11.   loaded: false,
  12.   children: [],
  13.   paths: [
  14.     'E:\\00_特训营\\day22\\代码\\node_modules',
  15.     'E:\\00_特训营\\day22\\node_modules',
  16.     'E:\\00_特训营\\node_modules',
  17.     'E:\\node_modules'
  18.   ]
  19. }
  20.  */

module.exports对象

  1. 在自定义模块中,可以使用module.exports对象,将模块内的成员分享出去,供外界使用,外界就可以用require()方法导入自定义模块时,得到的就是module.export对象所指向的内容
  1. const username = '张三'
  3. function sayHello(){
  4.     console.log('大家好,我是'+username);
  5. }
  7. //console.log(module);module.exports={} 没有值
  9. //给module.exports赋值,将来就可以导出
  10. module.exports.username=username
  11. module.exports.sayHello=sayHello
  13. //console.log(module);//module.exports={ username: '张三', sayHello: [Function: sayHello] } 有值了
  1.  const m = require('./07_模块间共享_定义');
  3.  console.log(m);
  5.  //调用属性和方法
  6.  console.log(m.username);
  7.  m.sayHello()

注意点:使用require()方法导入模块时,永远以module.exports对象所指向的对象为准

  1. const username = '张三'
  3. function sayHello(){
  4.     console.log('大家好,我是'+username);
  5. }
  7. //console.log(module);module.exports={} 没有值
  9. //给module.exports赋值,将来就可以导出
  10. module.exports.username=username
  11. module.exports.sayHello=sayHello
  13. //console.log(module);//module.exports={ username: '张三', sayHello: [Function: sayHello] } 有值了
  15. //让module.exports指向一个全新的对象
  16. module.exports = {
  17.     name:'李四',
  18.     age:24
  19. }
  21. //console.log(module);//module.exports={ name: '李四', age: 24 }
  1. const m = require('./09_模块间共享_定义_module.export使用注意');
  3. //验证了 导入模块的结果,永远以module.exports指向对象为主
  4. console.log(m);//{ name: '李四', age: 24 }

exports对象

exports和module.exports指向同一个对象

  1. console.log(exports);//{}
  2. console.log(module.exports);//{}
  3. console.log(exports === module.exports);//true 是同一个对象

由于module.exports单词写起来比较复杂,为了简化向外共享成员,node提供了exports对象对象,默认情况下,exports和module.expports指向同一个对象

  1. const username = '张三'
  3. function sayHello(){
  4.     console.log('大家好,我是'+username);
  5. }
  7. //console.log(module); //module.exports={} 没有值
  9. //简化操作,使用exports对外暴露成员
  10. exports.username=username
  11. exports.sayHello=sayHello
  13. //console.log(module);//module.exports={ username: '张三', sayHello: [Function: sayHello] } 有值了
  1. const m = require('./12_模块间共享_定义_使用exports');
  3. console.log(m);

module.exports对象和exports对象混合使用误区

  1. //module.exports对象和exports对象混合使用很容易出问题
  3. //误区一
  4. // 打印结果 { gender: '男', age: 23 }
  5. /* module.exports={
  6.     gender:'男',
  7.     age:23
  8. }
  9. exports.username='张三' */
  11. //误区二
  12. //打印结果 { username: '张三' }
  13. /* module.exports.username='张三'
  15. exports={
  16.     gender:'男',
  17.     age:23
  18. } */
  20. //误区三
  21. //打印结果 { username: '张三', gender: '男' }
  22. /* exports.username='张三'
  23. module.exports.gender='男' */
  25. //误区四
  26. //打印结果 { username: '张三', gender: '男', age: 23 }
  27. exports={
  28.     username:'张三',
  29.     gender:'男'
  30. } 
  31. module.exports = exports
  32. module.exports.age=23
  1. const m = require('./14_模块间共享_混合使用误区_定义');
  3. console.log(m);

module.exports对象和exports对象混合使用很容易出问题
时刻详记:require模块的时候,得到的永远是module.exports指向的对象

注意:为了防止混乱,建议大家不要在同一个模块中同时使用module.exports和exports对象

三. 核心模块(内置模块)

1 fs模块

fs模块(file system)文件操作系统, 主要功能是对目录/文件进行操作
fs模块时Node.js官方提供的,用来操作文件的模块,它提供了一系列的方法和属性,用来满足用户对文件的操作需求

使用

1,导入const fs = require(‘fs’)
2,调用方法
fs.readFile() 用于读取指定文件中的内容
fs.writeFile() 用于向指定文件中写入内容

读文件

fs.readFile(path, [options], callback)

  • path: 需要读取文件的路径
  • options: 编码格式, 一般为’utf8’ 表示以什么编码格式来读取文件
  • callback: 回调函数 文件读取完成后,通过回调函数拿到读取的结果
    • err: 错误对象
    • data: 数据

读取成功err就是null
读取失败err就是错误对象,dataStr的值就为undefined

  1. //1,导入
  2. const fs = require('fs');
  4. //2,调用readFile方法
  5. fs.readFile('./file/11.txt','utf8',function(err,dataStr){
  6.     //读取成功err就是null
  7.     //读取失败err就是错误对象,dataStr的值就为undefined
  8.     console.log(err);
  9.     console.log(dataStr);
  10. })

判断是否读取成功

  1. //1,导入
  2. const fs = require('fs');
  4. //2,调用readFile方法
  5. fs.readFile('./file/11.txt','utf8',function(err,dataStr){
  6.     //读取成功err就是null
  7.     //读取失败err就是错误对象,dataStr的值就位underfined
  8.     if(err==null){
  9.         console.log('读取文件成功'+dataStr);
  11.     }
  12.     return console.log('读取文件失败'+err.message); 
  14. })

写文件

fs.writeFile(file, data[, options], callback)

  • file: 需要写入的文件的路径
  • data: 需要写入的数据
  • options: 编码格式等, 一般为’utf8’ 表示以什么编码格式来读取文件
  • callback: 回调函数 文件写入完成后,通过回调函数拿到写入的结果
    • err: 出错对象
      ```javascript const fs = require(‘fs’);

fs.writeFile(‘./file/2.txt’,’222’,function(err){ //err为null表示写入成功 if(err == null){ return console.log(‘文件写入成功’); } console.log(‘文件写入失败’+err.message); })

  1. <a name="nf041"></a>
  2. ## 2 path模块
  3. path模块, 主要功能是对路径进行操作<br />用于处理路径的模块,提供了用于处理文件和目录的路径的实用工具
  5. <a name="ngaou"></a>
  6. #### 使用
  8.    1. 导入核心模块
  9.    1. 调用相关API(方法)
  10. <a name="BmEzn"></a>
  11. #### 方法
  12.     path.dirname(path):返回当前文件的所在的目录名<br />    path.join([...paths]) 拼接路径<br />    path.extname(path) 返回当前文件的扩展名<br />    path.basename(path[, ext])<br />        返回path的最后一部分,第二个是传后缀名,可选的,如果传了第二个参数,获取的就是文件名不含扩展名
  13. ```javascript
  14. const path = require('path');
  16. //node提供一些获取路径的简单写法
  17. //获取当前文件的完整路径(可以不用导入path模块)
  18. console.log(__filename);//E:\00_特训营\day22\代码\19_内置对象path_路径模块.js
  20. //获取当前文件所在的目录(可以不用导入path模块)
  21. console.log(__dirname);//E:\00_特训营\day22\代码
  23. //通过path获取当前文件所在的目录(了解)
  24. console.log(path.dirname(__filename));//E:\00_特训营\day22\代码
  26. //路径拼接获取1.txt的路径
  27. console.log(path.join(__dirname,'/file/1.txt'));//E:\00_特训营\day22\代码\file\1.txt
  29. //返回path的最后一部分
  30. console.log(path.basename(__filename));//19_内置对象path_路径模块.js
  31. console.log(path.basename(__filename,'.js'));//19_内置对象path_路径模块
  33. //获取文件的扩展名
  34. console.log(path.extname(__filename));//.js

3 http模块

超文本传输协议,要使用 HTTP 服务器和客户端，则必须 require(‘http’)。我们可以通过它创建服务器,这样就可以很方便的把一台普通的电脑变成一个web服务器,对外提供web资源服务

在网络中,负责对外提供网络资源的电脑,叫做服务器, 负责消耗资源的电脑,叫做客户端

服务器和普通电脑的区别在于,服务器上安装了web服务器软件
我们可以基于 node.js提供的http模块,通过几行简单的代码,就能轻松的搭建一个服务器软件,从而对外提供web服务

方法

  1. createServer( ) 创建一个服务器实例
  1. const http = require('http');
  3. //创建一个服务器实例
  4. const server = http.createServer()
  6. console.log(server);