Nodejs 入门基础知识点

Posted 2021-03-21 九爱

? 1、nodejs的安装
? 1.1 检测nodejs的版本 node -v (version:版本)
? 1.2 path配置nodejs 的环境变量（当前版本都是自动安装配置环境变量）指令： path
? 1.3 npm（node package mangment）node包管理工具
node之前版本是和npm分开的，两个模块是分别安装的，现在把npm打包到了node安装程序里面
2、什么是nodejs？

```
nodejs是javascript的运行环境，是一个执行js文件的平台。
nodejs存在类似于，其它的服务端语言，比如：java、php、python和C#等等。

javascript：是运行在浏览器端的基于对象、事件驱动机制的脚本语言。
nodejs：本身是一个平台是js的运行环境。

nodejs：要http、fs、path、url、querystring等模块。nodejs平台就是模仿os(操作系统)实现了各自的功能用来给服务器服务的。
```
3、nodejs的特点

```
1、事件驱动机制
2、单线程（异步操作 高效率的利用cpu资源）
3、非阻塞机制
```
4、repl环境

repl：可交互式运行环境

```
repl环境的退出：
1、指令 ".exit"
2、ctrl+c ：双击
```
5、node指令运行js文件

```
常用的dos指令：
cls：清除屏幕
cd: 改变文件路径 （.. 退出到上一级文件夹）
dir：统计当前文件夹下文件的列表
```

node指令：编译执行.js文件

6、nodejs和javascript的区别

```
1、javascript是基于对象、事件驱动机制运行在浏览器端的脚本语言。
2、nodejs是一个平台，支撑javascript运行的一个环境。nodejs封装了不同模块，比如http、fs、path等模块。就是用来做一个服务端的功能。
```
7、http模块

```
http:超文本传输协议
模块：nodejs平台实现的功能，抛出来给开发者使用。

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模块是nodejs的核心模块，主要功能就是用来读取，写入文件信息。

主要功能操作：它提供了文件的读取、写入、更名、删除、遍历目录、链接等POSIX文件系统操作。
```js
// 文件的读取、写入等操作

/**
* 文件异步读取
* 引入文件系统fs：file system
* 功能：读取文件，写入文件数据，删除文件、打开文件等
*/
// require(‘模块名称‘) 1、nodejs的核心模块
// 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 、nodejs服务器请求文件

2.1、案例步骤

```
1、使用nodejs创建一个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、核心模块与文件模块

```
nodejs是一个js运行环境，是一个平台。nodejs基于操作系统，封装了一些功能，http、tcp、udp，i/o模块、path、fs、stream等等。
以上这些通过nodejs内置的模块，它们就称为核心模块。http、fs、path等

文件模块：只要咱们写一个js文件，每一个文件都是模块。
注：核心模块是nodejs内置的一些功能模块，文件模块是开发人员编写的js文件
```

2、从模块外部访问模块内部的成员

```js
在nodejs中，一个文件又被称为一个模块。从一个模块访问外部模块中变量或方法
先创建了两个模块，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、模块对象的属性

```
什么是模块对象？
模块：核心模块（nodejs内置），第三方模块（第三方组织发布的），自定义模块（开发人员）
在nodejs平台上，每一个文件就可以称为一个模块。
定义了一个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 modelName@版本号
比如： npm install jquery@1.12.1
```

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 目录。 这样将会更快地加载，且更可靠。
```