V2AS问路
看完我的笔记不懂也会懂----Node.js
阅读原文时间：2023年07月08日阅读：1

Node.js 学习

命令行窗口

  1. 什么命令行窗口?

  2. 命令行窗口的别名？

  3. 常用命令

    dir： 列出当前目录下的所有文件
cd 目录名： 转到目标目录
cd .: 去当前目录
cd ..: 去上级目录
md 文件夹名称： 创建一个文件夹
rd 文件夹名称： 删除指定文件夹(如果文件夹中有文件不会删除)
rd /S 文件夹名称： 删除指定文件夹(删除文件夹不管其中是否有文件)

文件名： 打开指定文件
    (当我们使用cmd打开一个文件或者调用一个程序的时候，
    系统会首先在当前目录下寻找，
    如果没有就会到Path中寻找，
    还没找到就会报错)

  4. 环境变量(windows系统中的变量)

进程与线程

进程与线程的简单解释 -阮一峰

  1. 进程

  2. 线程

ECMAScript的缺点

  1. 没有模块化系统
  2. 标准库较少
  3. 没有标准接口
  4. 缺乏管理系统

Node模块化

  1. 在Node中，一个js文件就是一个模块

  2. 模块分为核心模块(Node提供的)与文件模块(用户自己编写的)

  3. 如何引入模块

  4. 默认下，每个模块都是独立的(闭包)，这意味着当前模块中无法访问到其他模块的变量与函数(作用域)，如果模块需要访问别的模块中的变量或方法，就需要将这些变量或方法向外暴露

    //02-module1
// 这个将作为一个模块被02-module2 引用
//向外暴露变量   其他模块可以看见
exports.a = 666;    //使用exports.变量名向外(别的模块)暴露

//02-module2

// node使用require("模块路径")
//使用require()引入模块以后，会返回一个对象，这个对象包含引入模块中的所有变量、函数
var module02 = require("./02 Node module.js");  //引入模块

console.log(module02);      //{ a: 666 }
console.log(module02.a);    //666

  5. 证明文件模块是在一个函数内

    //证明模块就是一个函数
var a = 666;
//方式一:  函数外部是全局作用域global，如果此时定义的a在global中无法看到说明现在位于函数中
console.log(global.a);  //undefined

//方式二: 利用   不用声明符声明会变为全局变量的原理 反证位于函数中
b = 'i am in global !';
console.log(global.b);  //'i am in global !'

//方式三:  利用 arguments 只有在函数中才有的特性
console.log(arguments);

//方式四:  利用arguments.callee查看当前函数
console.log(arguments.callee)   //function

//方式五(最终方式)： 直接能够查看整个函数
console.log(arguments.callee.toString())


//当执行模块中的代码时候,会将代码包装在一个函数中运行，同时传进5个参数
function (exports, require, module, __filename, __dirname){
    你的代码
    exports ： 该对象是 module对象的属性    用于储存   暴露在外部(全局global)的属性与方法
    require :  该对象储存这该模块的一些信息
    module：  该对象储存这模块的详细信息，其中就有exports
    __filename： 值是这个模块的详细路径
     __dirname： 值是这个模块所在的文件路径
}

  6. 关于exports与module.exports

    exports、module.exports作用是：能够像外暴露属性与方法(别忘记了模块是在一个函数中的，所以在其中定义的变量与方法都是属于局部作用域的)

    //exports与module.exports指向的是同一个对象
console.log(exports === module.exports) //true

//可以给module.exports直接赋值一个新的对象，用于一次性向外暴露多个变量或方法
module.exports = {
    name: 'Fitz',
    gender: 'Male',
    address: 'Dongguan'
}
console.log(arguments[2].exports)   //{ name: 'Fitz', gender: 'Male', address: 'Dongguan' }

//但是不能给exports直接赋值新的对象，来达到一次性暴露多个属性与方法的目的
exports = {
    name: 'dada'
}
//在别的模块中可以看到exports并没有改变
console.log(arguments[2].exports)   //{ name: 'Fitz', gender: 'Male', address: 'Dongguan' }

//原因
//module.exports与exports的关系应该是这样的:
var module_exports = {} //module.exports指向一个对象
var exports = module.exports  //exports与module.exports绑定同一个对象
//如果修改的是module.exports
var module.exports = new Object();  //exports的引用也随之发生改变
//但是如果修改的是exports就等于
var exports = new Object();

//此时module.exports  与  exports引用的是两个不同的对象
//而由于真正向外暴露的对象是module.exports，所以在引用 这个模块的文件中
//只能看到module.exports的修改而看不到exports修改的

Node中的全局对象

Node中的 全局对象 为 global ====> 相当于浏览器中的 window

包 package

包就是将一组相关模块组合到一起，形成一个完整的工具

  1. 包的组成

NPM包管理器 (Node Package Manager)

Npm参考 -阮一峰

常用命令

1. npm -v ===> 查询npm的版本

2. npm =====> 查看帮助说明

3. npm search 包名 =====> 搜素模块包

4. npm install 包名 ====> 安装包

5. npm install 包名 --save ====> 安装并将包添加到依赖(dependencies)中

6. npm install 包名 --save-dev ====> 安装并将包添加到开发依赖(devDependencies)中

7. npm install ===> 安装当前环境中依赖的所有包

8. (重要) npm install -g 包名 ===> 全局模式安装包

9. npm remove 包名 或者 npm r 包名 =====> 删除模块包

10. (重要) npm init ===> 初始化生成package.json文件

需要注意:

1. 通过npm或cnpm下载的包都放在node_modules文件夹中，使用时直接将包名引入即可

2. node在引入模块的时候，如果直接使用模块名字，会首先在当前目录中的node_modules中寻找是否有该模块，如果有则使用，没有则去上一级目录中的node_modules中寻找，循环直到当前包所在磁盘根目录，找到使用，没找到报错

package.json参数详解

{
    "name": "当前项目的名称",
    "version": "1.2.3 版本（遵守“大版本.次要版本.小版本”的格式）",
    "author": "作者",
    "description": "关于包的描述",
    "keywords":["node.js","javascript"," ===>包的描述关键字"],
    "repository": {     包所在的远程仓库
        "type": "git",
        "url": "https://path/to/url"
    },
    "license":"许可",
    "engines": {"node": "指明了该项目所需要的node.js版本"},
    "bugs":{"url":"http://path/to/bug",
            "email":"bug@example.com",
            "用途": "bug提交的地址或者邮箱"
            },
    "contributors":[{"name":"李四","email":"lisi@example.com"},
                    {"用途": "标明开放包的贡献人士"}],
    "scripts": {
        "start": "node ./index.js",
        "用途": "使用node run [key]可以运行script中key对应的value中的代码"
        "例如": "在终端运行node run start就等于运行node ./index.js"
    },
    "dependencies": {
        "express": "latest",
        "mongoose": "~3.8.3",
        "handlebars-runtime": "~1.0.12",
        "express3-handlebars": "~0.5.0",
        "MD5": "~1.2.0",
        "用途": "所依赖的环境(必须有这些包才能正常运行当前包)"
    },
    "devDependencies": {
        "bower": "~1.2.8",
        "grunt": "~0.4.1",
        "用途": "开发这个包时用的环境,但是在生成环境中可以省略的包"
    },
    "main": {"用途": "指定整个包的入口文件  默认是: index.js"}
}

Buffer 缓冲区

  1. Buffer的结构、操作的方法与数组很像

  2. Buffer弥补了 数组 不能储存二进制数据 的缺点

  3. Buffer存储二进制数据，但是以16进制的方式显示

  4. Buffer的大小一旦确定了就不能再修改

  5. Buffer相关方法

    Buffer.from(str)    //将一个字符串转换为buffer
buffObj.toString()  //将buffer实例对象转换为字符串
Buffer.alloc(size)  //创建一个指定大小的Buffer
Buffer.allocUnsafe(size)//创建一个指定大小的Buffer，但是其中是用过的内存(没有清空)

fs(file system) 文件系统

fs就是通过Node来操作系统中的文件

fs是核心模块，不需要下载便可直接引入

文件写入

  1. 同步写入文件

    var fs = require('fs');  //引入fs核心模块

//找到并打开文件
var f = fs.openSync('test.txt','w');
//以同步方式写入文件
fs.writeSync(f,'write success');
//保存并关闭同步模式的文件
fs.closeSync(f);

  2. 异步写入文件

    //异步操作文件
var fs = require('fs');  //引入fs核心模块

//找到并打开文件
//fs.open(path,flag,callback(e,f))
//e是错误信息，没错误返回null
//f是文件的标识符

fs.open('test2.txt','w',function(error,file){
    if(error){
        console.log(error);
    }
    //以异步模式写入文件
fs.write(file,'异步写入成功',function(e){
    if(e){
    console.log(e);
}
    console.log('写入方法的回调已被执行');
});
//保存并关闭异步模式的文件
fs.close(file,function(e){
    if(e){
    console.log(e);
}
    console.log('文件关闭成功');
});
    });

  3. 简单文件写入

  4. 流式文件写入

解决同步、异步、简单文件写入三种模式性能较差，容易导致内存溢出的问题

var fs = require('fs');  //引入fs核心模块

//创建一个可写流
var ws = fs.createWriteStream('writeStream.txt');
//通过可写流向文件中写入内容
ws.write("通过可写流写入第1个内容\n");
ws.write("通过可写流写入第2个内容\n");
ws.write("通过可写流写入第3个内容\n");
//关闭可写流
ws.end()
文件读取

  1. 同步文件读取

  2. 简单文件同步读取

    var fs = require("fs");
//找到并读取文件
var f = fs.readFileSync('test.txt');
console.log(f.toString());

  3. 异步文件读取

  4. 简单文件异步读取

    var fs = require("fs");
//找到并读取文件
var f = fs.readFile('test2.txt',function(e,f){
    if(e){
        console.log('读取失败...');
        console.log(e);
    }
    console.log(f.toString());
});

  5. 流式文件读取

    可以多次将文件读取到内存中

    //流式文件读取
var fs = require("fs");
//创建一个可读流
var rs = fs.createReadStream('writeStream.txt');
//创建一个可写流
var ws = fs.createWriteStream('writeStream2.txt');

/*//读取可读流中的数据，必须绑定一个data事件，绑定完毕后会自动开始读取数据
rs.on('data',function(data){
    console.log(data.toString());
    //将可读流中的数据复制写入到 writeStream2.txt 中
    ws.write(data);
})
rs.once('close',function(){
    ws.close();
})*/

//简化读写过程
rs.pipe(ws);    //自动读取   自动写入  自动关闭
其他方法

  1. 检查文件状态

    var fs = require("fs");
fs.stat('test.txt',function(error,statusInfo){
    console.log(statusInfo);
    //statusInfo中的各种检测
    console.log(statusInfo.isFile());
    console.log(statusInfo.isDirector());
})

  2. 删除文件

    //删除一个文件
var fs = require("fs");
fs.unlinkSync('beenRemove.txt')

  3. 修改/限制文件的大小

    var fs = require("fs");
fs.truncateSync('test.txt',3)   //将test.txt文件修改为3 bytes大小

  4. 创建文件夹

    var fs = require("fs");
fs.mkdirSync('newCollect');

  5. 列出文件夹中的所有文件

    var fs = require("fs");
fs.readdir('./',function(error,files){
    console.log(error);
    console.log(typeof files);  //Object array
    console.log(files.length);
    console.log(files);
})

  6. 删除文件夹

    var fs = require("fs");
fs.rmdirSync('newCollect');

  7. 重命名文件夹

    var fs = require("fs");
fs.rename('newCollect','newCollects',function(){
    console.log('dd');
});

  8. 监听文件

    var fs = require("fs");
fs.watchFile('test.txt',{interval:1000},function(curr,prev){
    console.log('File has been modify');
    console.log(curr);  //修改前的stat(文件的status状态信息)对象
    console.log(prev);  //修改后的stat(文件的status状态信息)对象
})

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器

你可能感兴趣的文章