? 1,Node.JS 的安装
? 1.1 检测 Node.JS 的版本 node -v (version: 版本)
? 1.2 path 配置 Node.JS 的环境变量 (当前版本都是自动安装配置环境变量) 指令: path
? 1.3 NPM(node package mangment)node 包管理工具
node 之前版本是和 NPM 分开的, 两个模块是分别安装的, 现在把 NPM 打包到了 node 安装程序里面
2, 什么是 Node.JS?
```
Node.JS 是 JavaScript 的运行环境, 是一个执行 JS 文件的平台.
Node.JS 存在类似于, 其它的服务端语言, 比如: java,PHP,python 和 C# 等等.
JavaScript: 是运行在浏览器端的基于对象, 事件驱动机制的脚本语言.
Node.JS: 本身是一个平台是 JS 的运行环境.
Node.JS: 要 http,fs,path,url,querystring 等模块. Node.JS 平台就是模仿 os(操作系统)实现了各自的功能用来给服务器服务的.
```
3,Node.JS 的特点
```
1, 事件驱动机制
2, 单线程(异步操作 高效率的利用 CPU 资源)
3, 非阻塞机制
```
4,repl 环境
repl: 可交互式运行环境
```
repl 环境的退出:
1, 指令 ".exit"
2,ctrl+c : 双击
```
5,node 指令运行 JS 文件
```
常用的 dos 指令:
cls: 清除屏幕
cd: 改变文件路径 (.. 退出到上一级文件夹)
dir: 统计当前文件夹下文件的列表
```
node 指令: 编译执行. JS 文件
6,Node.JS 和 JavaScript 的区别
```
1,JavaScript 是基于对象, 事件驱动机制运行在浏览器端的脚本语言.
2,Node.JS 是一个平台, 支撑 JavaScript 运行的一个环境. Node.JS 封装了不同模块, 比如 http,fs,path 等模块. 就是用来做一个服务端的功能.
```
7,http 模块
```
http: 超文本传输协议
模块: Node.JS 平台实现的功能, 抛出来给开发者使用.
http 模块可以创建一个 server 服务器
1 http 模块讲解
2 req,res 详解
3 端口号作用
同一台服务器可以接收多个应用, 只要是端口号不同, 就可以访问不同的服务.(端口号的不同可以创建不同的服务和应用)
(1--1000)端口号都是给系统 (win 系统) 服务的.
ftp:21 80 端口 打印机用 443 端口
一般情况都是 4 位数字的端口号
4 req.url
默认情况下 取值 "/"
如果主机名 (localhost) 和端口号后面有数据, 那么 req.url 取值就是端口号后面的数据
- 5 res.write()
- res:response
- res.write();//(服务端向客户端发送数据)
- 6 res.end()
end(): 结束 服务端停止结束对客户端的响应.
在结束之前还可以做最后的输出
```
fs 文件系统模块
fs 模块是 Node.JS 的核心模块, 主要功能就是用来读取, 写入文件信息.
主要功能操作: 它提供了文件的读取, 写入, 更名, 删除, 遍历目录, 链接等 POSIX 文件系统操作.
- ```JS
- // 文件的读取, 写入等操作
- /**
- * 文件异步读取
- * 引入文件系统 fs:file system
- * 功能: 读取文件, 写入文件数据, 删除文件, 打开文件等
- */
- // require('模块名称') 1,Node.JS 的核心模块
- // 2, 开发者自己写的 JS 文件(一个文件就被称为模块)
- var fs = require('fs');
- // 异步读取文件
- /**
- * 1, 要读取的文件路径
- * 2, 读取文件时用到的字符编码
- * 3, 回调函数 要来输出读取成功或失败的信息
- * readFile: read: 读 file: 文件
- */
- fs.readFile('./studentMsg.txt','utf8',function(err,data){
- // 如果文件读取失败 就报 err 错误信息 data: 读取文件成功的信息
- if(err){
- // 如果读取失败 就输出错误信息 message: 消息
- console.log('读取文件失败:',err.message);
- }else {
- console.log(1111);
- // 如果读取文件成功 就把文本文件中的信息输出到控制台
- console.log(data);
- }
- });
- // 输出 console.log('2222');add();
- function add(){
- console.log(333);
- }
- ```
- ```JS
- // 同步读取文件
- // 同步读取文件
- // 引入文件模块
- var fs = require('fs');
- /**
- * 同步读取
- * 参数: 1, 文本文件(给他一个正确的路径)
- * 2, 字符编码(utf8: 全球所有的字符都收录)
- * */
- var data = "";
- try {
- data = fs.readFileSync('./studentMsg.txt','utf8');
- console.log('data:',data);
- } catch (err) {
- console.log("error:",err);
- }
- // 所有的程序语言中 都有 try...catch 异常捕获机制
- // try: 试一试 试着做 catch: 抓住 捕获
- console.log(2222);
- ```
1.3, 写入文件
- ```JS
- // 异步写入文件
- // 异步写入文件
- var fs = require('fs');
- /**
- * writeFile:write(写)file(文件)
- * 参数 1, 给定一个要写入的文件
- * 2, 要写入的数据
- * 3, 字符编码
- * 4, 回调函数: 返回文件写入失败或成功信息
- */
- var msg = "1907A 披荆斩棘";
- fs.writeFile('./teacherMsg.txt',msg,'utf8',function(err){
- if(err){
- console.log('写入文件失败:',err);
- }else {
- console.log(1111);
- console.log('写入文件成功');
- }
- });
- console.log(2222);
- ```
1.4, 同步和异步的区别
```
同步: 执行一个方法, 只有方法给出结果后, 才算结束
异步: 执行一个方法, 只是交代要做的事情, 然后去做其它事情, 而交代的事件在回调中处理.
```
1.5, 同步追加文件
- ```JS
- // 同步追加文件内容
- var fs = require('fs');
- console.log(111);
- try {
- fs.appendFileSync('./classInfo.txt','今天的你感谢曾经奋斗的你','utf8');
- console.log(222);
- } catch (error) {
- console.log(error);
- }
- console.log(333);
- ```
1.6, 异步追加文件内容
- ```JS
- // 向文件中追加内容 是不清楚原有数据的情况下 进行的
- // 写入数据 每次都要把原来的数据清除掉
- var fs = require('fs');
- /* fs.writeFile('./classInfo.txt','1907A 班','utf8',function(err,data){
- if(err){
- console.log('写入数据失败');
- }else {
- console.log('写入数据成功',data);
- }
- }); */
- console.log(111);
- fs.appendFile('./classInfo.txt','新追加的内容','utf8',function(err){
- console.log(2222);
- if(!err){
- console.log('追加文件内容成功');
- }
- });
- console.log(3333);
- ```
- #### 2 ,Node.JS 服务器请求文件
2.1, 案例步骤
```
1, 使用 Node.JS 创建一个 http 的服务器
2, 引入 fs 文件系统模块
3, 根据浏览器中的 url 地址不同来读取对应的文件
路径:"/", 读取 index.html
"/list.html", 读取 list.HTML
"/CSS", 读取 style.CSS 文件
4, 将读取的文件信息输出到浏览端
- ```
- ```JS
- // 引入 http 模块
- var http = require('http');
- var fs = require('fs');
- http.createServer(function(req,res){
- var url = req.url;
- // 设置头信息, 读取不同文件
- res.writeHead(200,{"Content-Type":"text/html/css;charset=utf8"});
- if(url == '/') { // "/", 读取 index.HTML
- // 回调的是 错误和成功的信息和数据
- fs.readFile('./index.html','utf8',function(err,data){
- if(err){
- res.write('读取 index.html 文件失败');
- res.end();
- }else {
- res.write(data);
- res.end();
- }
- });
- } else if(url == "/list.html"){ // "/list.html", 读取 list.HTML
- fs.readFile('./list.html','utf8',function(err,data){
- if(err){
- res.write('读取 list.html 文件失败');
- res.end();
- }else {
- res.write(data);
- res.end();
- }
- });
- } else if(url == "/css"){
- fs.readFile('./style.css','utf8',function(err,data){
- if(err){
- res.write('读取 css 文件失败');
- res.end();
- }else {
- res.write(data);
- res.end();
- }
- });
- }
- }).listen(3000,function(){
- console.log('server success!');
- });
- ```
3,favicon.ico 文件是网站图标
1, 核心模块与文件模块
```
Node.JS 是一个 JS 运行环境, 是一个平台. Node.JS 基于操作系统, 封装了一些功能, http,tcp,udp,i/o 模块, path,fs,stream 等等.
以上这些通过 Node.JS 内置的模块, 它们就称为核心模块. http,fs,path 等
文件模块: 只要咱们写一个 JS 文件, 每一个文件都是模块.
注: 核心模块是 Node.JS 内置的一些功能模块, 文件模块是开发人员编写的 JS 文件
```
2, 从模块外部访问模块内部的成员
```JS
在 Node.JS 中, 一个文件又被称为一个模块. 从一个模块访问外部模块中变量或方法
先创建了两个模块, demo1,demo2
在 demo1 中声明的变量 str, 方法 add()
在 demo2 中没有权限访问, 如果要访问到的话, 就要把变量或方法做成全局属性
用到 global 来把 str 和 add 函数变成全局属性
- global.str = "声明变量";
- global.add = function(){
- console.log('函数表达式');
- }
在 demo2 中就可以访问到 str 和 add().
```
2.1, 使用 exports 对象
- ```JS
- // exports 这个对象的属性 是可以将模块内的方法, 变量等抛出, 并且在其它引入的模块中可见(可使用)
- // demo1.JS
- exports.str = "hello";
- exports.hello = function(){
- console.log('你好世界');
- }
- // 在 demo2.JS 中引入 demo1.JS 文件 可以使用 demo1 中的变量和方法
- var demo1 = require('./demo1');
- demo1.hello();
- demo1.str; // 这里是 str 变量的调用 需要 console.log 才能看到
- ```
2.2, 将模块定义为类
- ```JS
- // class 是在 ECMAScript2015 版本之后加入的概念 es6
- // class 关键字: 确定一个类型 Student 以类概念的存在
- class Student {
- // 构造函数 默认存在一个无参的构造函数
- constructor(n,a){
- this.name = n;
- this.age = a;
- }
- // 函数表达式
- add = function(){
- console.log('add');
- }
- }
- module.exports = Student;
- ```
2.3, 将模块定义为类变量和类函数
- ```JS
- // 返回一个 JSON Object
- var App = {
- name: 'app',
- version: '1.0.0',
- sayName: function(name){
- console.log(this.name);
- }
- }
- module.exports = App;
- // 调用模块
- var App = require('./app.js');
- App.sayName('hello');//hello
- // 定义变量
- // 定义函数
- var func1 = function() {
- console.log("func1");
- };
- var func2 = function() {
- console.log("func2");
- };
- exports.function1 = func1;
- exports.function2 = func2;
- // 函数调用
- var functions = require("./functions");
- functions.function1();
- functions.function2();
- ```
3, 模块对象的属性
```
什么是模块对象?
模块: 核心模块(Node.JS 内置), 第三方模块(第三方组织发布的), 自定义模块(开发人员)
在 Node.JS 平台上, 每一个文件就可以称为一个模块.
定义了一个 modules 它在模块内就是一个模块对象. 每一个模块内斗内置了一个对象就是 module(模块)
每个模块对象都代表当前模块. 使用 module.exports 时才能把整个的模块文件作为一个对象抛出.
模块对象的属性: exports 就是 module.exports 定义的属性.
```
> 注: module.exports 和 exports 的区别
>
> 1. module.exports 初始值为一个空对象 {}
> 2. exports 是指向的 module.exports 的引用
> 3. require() 返回的是 module.exports 而不是 exports
4,NPM 包管理工具
```
什么是 NPM?
node package management:node 包管理工具 (主要管理模块)
模块: 核心模块, 文件模块
文件模块: 自定义模块, 第三方模块
NPM 就是用来管理和安装第三方模块的
NPM 命令详解
1,NPM -v // v:version(版本)
NPM -v 查看当前 NPM 的版本号
2, 安装模块
命令: NPM install model name (模块名称)
比如: 安装 jQuery 模块
NPM install jQuery
查看 NPM 中模块的清单命令
NPM list 这个命令会列出所有安装的第三方模块
3, 卸载模块 uninstall: 卸载
命令: NPM uninstall modelname (模块名称)
卸载 jQuery 模块
NPM uninstall jQuery
4,NPM 清单指令
NPM list 把当前安装的所有第三方模块列出
5, 查看给定模块的信息
指令: NPM info modelName(模块名称)
比如: 查看 jQuery 的信息
NPM info jQuery
6, 指定模块版本号安装
指令: NPM install [email protected]版本号
比如: NPM install [email protected]
```
5,NPM 发布流程
```
1, 注册 NPM 账号
2, 登录 NPM 账号
3, 创建工程项目包 NPM init 包名称 -y
4, 发布程序包到 NPM
5, 执行命令 NPM publish
```
6, 安装淘宝镜像
```
NPM 中的淘宝镜像 cnpm C: 中国 china
镜像: 把国外一些数据放到国内服务器上.
cnpm 就是把 NPM 平台上的模块等功能文件, 都放到淘宝的服务器上. 国内用户在访问的时候就方便了.
NPM install 模块,
cnpm 把 NPM 的功能都复制了一遍, NPM 的指令在 cnpm 上都可以使用.
注: 使用 设置淘宝镜像地址
安装 cnpm
通过 NPM 指令安装: NPM install cnpm -g --registry=https://registry.npm.taobao.org;
```
package.JSON 文件
```
package.JSON 文件作用
1, 用来描述工程项目的信息
2, 描述第三方模块之间的依赖
注: 1, 通过 NPM init 指令来创建 package.JSON
2, 快速创建 package.JSON 文件的指令 NPM init -y
3, 给 package.JSON 文件增加模块依赖的指令
NPM install 模块名称 --save(将模块增加到当前 package.JSON)
```
7, 组织与管理模块
- ```
- var http = require('http');
- // 管理模块 : 第三方模块 比如 jQuery s-date 这样的开源模块
- var jq = require('jquery');
- var date = require('s-date');
- // 三种方式可以加载
- // 1, 从 node-modules 文件夹下面加载
- // 2, 从 package.JSON 文件的目录中加载
- // 3, 从全局目录中加载(node 配置的环境变量)
- // 注: 建议把所有的第三方模块, 都安装到本地文件夹的 node-modules 里面
- ```
7.1, 从 node-modules 目录中加载模块
```
如果传递给 require() 的模块标识符不是一个核心模块, 也没有以 '/' , '../' 或 './' 开头, 则 Node.JS 会从当前模块的父目录开始, 尝试从它的 /node_modules 目录里加载模块.
如果还是没有找到, 则移动到再上一层父目录, 直到文件系统的根目录.
例子, 如果在 '/home/ry/projects/foo.js' 文件里调用了 require('bar.js'), 则 Node.JS 会按以下顺序查找:
- /home/ry/projects/node_modules/bar.JS
- /home/ry/node_modules/bar.JS
- /home/node_modules/bar.JS
- /node_modules/bar.JS
这使得程序本地化它们的依赖, 避免它们产生冲突.
```
7.2, 使用目录加载模块
```
可以把程序和库放到一个单独的目录, 然后提供一个单一的入口来指向它. 把目录递给 require() 作为一个参数, 有三种方式.
第一种方式是在根目录下创建一个 package.JSON 文件, 并指定一个 main 模块. 例子, package.JSON 文件类似:
- {
- "name" : "some-library",
- "main" : "./lib/some-library.js"
- }
- ```
7.3, 从全局目录中加载模块
```
如果 NODE_PATH 环境变量被设为一个以冒号分割的绝对路径列表, 则当在其他地方找不到模块时 Node.JS 会搜索这些路径.
在 Windows 系统中, NODE_PATH 是以分号 (;) 间隔的.
强烈建议将所有的依赖放在本地的 node_modules 目录. 这样将会更快地加载, 且更可靠.
```
来源: http://www.bubuko.com/infodetail-3342814.html