Node.js_基础

Node安装

找到自己系统然后搜索百度 node安装即可;
查看是否安装成功 -> cmd -> node -v 有看到版本的时候表示安装成功~

配置环境变量

一般情况下node会自动配置好环境变量,若还真没有就 百度搜索 -> node环境配置~

什么是服务端什么是客户端

node装好了之后,就可以使用node执行js文件
也可以通过node来搭建服务器,当搭建了服务器之后电脑就是一个服务端

console.log("我是index.js");

如何说这段代码是js文件还是 node.js 文件呢.需要看你放在那里执行
1.客户端 -> index.html -> script
2.node -> node index.js

服务端语言是可以搭建服务器的:
node是如何搭建服务器的呢?
服务器和客户端又有什么区别?
实际上任何电脑都可以当成一个服务器

第一个node.js服务器

const http = require("http");
const server = http.createServer((req,res)=>{
    res.write("hello world");
    res.end();
})
server.listen(3000);//3000 -> 端口号

运行:
1.是用node启动
　　node http.js
2.访问:
　　本地:
　　　　localhost:3000
　　　　127.0.0.1:3000
　　同局域网:
　　　　ip地址:3000 -> 使用ipconfig找到服务器端ip

服务端修改内容刷新:
　　1.修改好内容需要重启node
　　2.客户端再进行刷新
　　确定每次都需要重启一次node
第二种启动node方法
　　nodemon -> 前期需要安装一下!
　　nodemon http.js
　　可以达到保存就重启服务器效果

服务端是如何写的?

//require是node.js里面的规范,在做模块化的时候,引入模块的语法行; -> 相当是引入一个模块,引入http模块

// 我们如果使用node的时候,自动会把每个文件划分成一个模块,文件和文件之间会有相对应的引用关系;也不存在变量污染;

require与exports 模块的引用和导出

可以文件或文件夹的引用和导出

// 客户端模块化的代表
// AMD sea.js CMD require.js
// 在node中模块是天生的,装完之后就会有模块化
console.log("我是index.js");
{
    // 引入
    let Ma = require("./Ma.js");//这个require是node已经定义的了;
    // 执行node的时候 会执行index.js 和 Ma.js
    {
        // 模块化: 优势1.每一个模块都会有自己的独立命名空间
        // console.log(a);//这里是没有a的
    }
    {
        // 如何得到Ma.js 里面的a呢?
        // 在Ma中导出就行 -> module.exports = {a}
        console.log(Ma.a);
        let cai = new Ma.Preson();
        console.log(cai.name);
        cai.hobby();
    }
    // 注意点: 引入的 ./ 是不能省掉的; .js后缀可以省

    {
        // 引入文件
        require("./home")
    }
}

console.log("我是Ma.js文件");
let a = 10;
class Preson {
    constructor() {
        this.name = "张三"
    }
    hobby() {
        console.log("喜欢篮球")
    }
}

// 导出
// 也可以导出类
{
    // module.exports = {
    //     a,
    //     Preson
    // }
}
{
    // exports
    exports.a = a;
    exports.Preson = Preson;
    // exports是module.exports的引用
    // module.exports = exports;
}

{
    // 也是可以引入别的模块文件:
    require("./Mb.js")
}

针对于node的文件夹管理

{
    // 引用node自带的模块
    require("mytest");
    // 注: 这里是直接模块文件名即可
    // 默认情况下,回去找文件夹里面的index.js
        // 所以可以来一个描述性文件 package.json (固定死文件名);
    {
        // let {a,b} = require("mytest");
        // console.log(a);//10;
        // b();
    }
    {
        // 通过json方式
        // 我是Main.js文件 可以修改默认文件
    }
}
{
    /* 
        总结:
            可以通过文件和文件夹
                文件注意需要./
            node_modules
    */
}

{
    "name": "mytest",
    "version": "1.0",
    "main": "main.js"
}

node的一些模块

{
    const http = require("http");//引入http模块 -> http是内置模块,官方模块,不需要下载,不需要自定义,已经集成到了node.js里面了
    // 很多情况下,自己写的模块会放到一个文件夹中,别人写的模块放到node的模块文件夹中,那么如何获取别人的模块呢?
    // 在node里面就有npm管理和下载第三方模块 -> 包管理器
    {
        // npm 安装
            // npm install jquery
            // 可以把jq安装到node_modules里面
            // 也可以 npm i cookie
        // 创建package.json
            // npm init
            // 一路确认...
        // 删除
            // npm uninstall cookie

        // 新版本安装的 --save
            // npm i axios --save
            //在package中dependencies新增一个axios
            // 现在默认都会有
        // dependencies:运行依赖
            // 不管是开发的时候需要用,正式的时候也要用
        // devDependencies:开发依赖
            // 可以理解为,在开发的时候需要使用这个依赖,在正式运行的时候不需要用这个
            // npm i axios --save-dev
        // 当没有node_modules的时候:
            // npm i -> 会自动下载所需要的依赖
        // node_modules特性,可以按照文件夹一层一层往上面找
            // 最终会找到 npm root -g
        // npm i jquery -g
            // 这个可以装到全局中 也就是 root -g文件夹哪里
        // 版本需求:
            // npm i jquery@3.4.1
    }
}

内置模块之fs模块

const fs = require("fs");//文件操作
// 增删改查;
// 1.文件操作   2.目录操作
{
    // 文件操作
    {
        // fs.writeFile("1.txt", "我是写入的文字", function (err) {
        //     if (err) {
        //         return console.log(err)
        //     }
        //     console.log("写入成功")
        // });//写
    }
    {
        //a:追加写入; w:写入 r:读取
        // fs.writeFile("1.txt","我是追加文字",{flag:"a"},function(err){
        //     if(err){
        //         return console.log(err)
        //     }
        //     console.log("写入成功")
        // })
    }
    {
        // 文件读取
        {
            // fs.readFile("1.txt", "utf8", (err, data) => {
            //     if (err) {
            //         return console.log("读取失败");
            //     }
            //     console.log(data)
            // })
        }
        {
            // 没有utf8
            // fs.readFile("1.txt",(err,data)=>{
            //     if(err){
            //         return console.log("读取失败");
            //     }
            //     console.log(data.toString())
            // })
        }
    }
    // 所有文件操作 没有加Sync都是异步 否则是同步;
    // let data = fs.readFileSync("1.txt");
    // console.log(data.toString())
    {
        // 修改;(修改名称);
        // fs.rename("1.txt","2.txt",err=>{
        //     if(err){
        //         return console.log(err);
        //     }
        //     console.log("修改成功");
        // });
    }
    {
        // 删除;
        // fs.unlink("2.txt",err=>{
        //     if(err){
        //         return console.log(err);
        //     }
        //     console.log("删除成功");
        // });
    }
    {
        // 复制; 先读取再写入的过程..
        {
            // fs.copyFile("index.html", "myindex.html", err => {
            //     if (err) {
            //         return console.log(err);
            //     }
            //     console.log("复制成功");
            // })
        }
        {
            // function mycopy(src,dest){
            //     fs.writeFileSync(dest,fs.readFileSync(src));
            // }
            // mycopy("index.html","test.html");
        }
    }
}

{
    // 目录操作
    {
        // 创建目录
        // fs.mkdir("11",err=>{
        //     if(err){
        //         return console.log(err);
        //     }
        //     console.log("创建成功");
        // });
    }
    {
        // 修改目录(名称)
        // fs.rename("11","22",err=>{
        //     if(err){
        //         return console.log(err);
        //     }
        //     console.log("修改成功");
        // })
    }
    {
        // 读取目录
        // fs.readdir("22",(err,data)=>{
        //     if(err){
        //         return console.log(err);
        //     }
        //     console.log(data);
        // })
    }
    {
        // 删除目录(空文件夹/目录)
        // fs.rmdir("11",err=>{
        //     if(err){
        //         return console.log(err);
        //     }
        //     console.log("删除成功");
        // })
    }
}

{
    {
        // 判断文件或者目录是否存在 -> 返还布尔值
        // fs.exists("index.html", exists => {
        //     console.log(exists);
        // });
        // 实际运用的时候,若需要创建目录或文件的时候,可以使用它判断是否存在;
    }
    {
        // 获取文件或目录的详细信息
        // fs.stat("index.html", (err, stat) => {
        //     if (err) {
        //         return console.log(err);
        //     }
        //     // console.log(stat);
        //     {
        //         // 判断是否是文件: -> 布尔值
        //         let res = stat.isFile();
        //         console.log(res);
        //     }
        //     {
        //         // 判断是否是文件夹 -> 布尔值
        //         let res = stat.isDirectory();
        //         console.log(res);
        //     }
        // })
    }
    {
        // 删除文件夹(非空文件夹)
        // 先把目录里文件删除->删除空目录;
        function removeDir(path){
            let data = fs.readdirSync(path);//得到目录下的文件或文件夹 [ '1.txt', '2.html', '33' ]
            for(let i = 0;i<data.length;i++){
                // 判断是文件或是目录 -> 文件 直接删除 : 目录执行这个函数(继续查找);
                let url = path + "/" + data[i];//路径 -> 注意是需要上级的
                let stat = fs.statSync(url);
                if(stat.isDirectory()){//目录
                    removeDir(url);
                }else{
                    fs.unlinkSync(url);
                }
            }
            // 这时候文件已经删除完毕;
            fs.rmdirSync(path);//删除空目录
        }
        // removeDir("22");//注意执行node删除操作的时候,一定要记得备份,免得赵成没必要的影响;
    }
}

 buffer.js

// buffer在nodeJS里面是一个类,也可以理解为一种数据格式,可以通过buffer转换成二进制格式数据;
// 二进制数据在底层传输是非常快的
{
    // buffer 创建
    // new Buffer(); -> 6.0之前的创建..
    {
        // 手动创建
        let buffer = Buffer.alloc(10);
        console.log(buffer);//<Buffer 00 00 00 00 00 00 00 00 00 00>
    }
    {
        // 字符串形式
        let buffer = Buffer.from("大家好");
        console.log(buffer);//<Buffer e5 a4 a7 e5 ae b6 e5 a5 bd>
    }
    {
        // 数组形式
        let buffer = Buffer.from([0xe5,0xa4,0xa7,0xe5,0xae,0xb6,0xe5,0xa5,0xbd]);
        console.log(buffer);//<Buffer e5 a4 a7 e5 ae b6 e5 a5 bd>
        console.log(buffer.toString());//大家好
    }
    {
        // 乱码buffer
        let buffer1 = Buffer.from([0xe5,0xa4,0xa7,0xe5]);
        let buffer2 = Buffer.from([0xae,0xb6,0xe5,0xa5,0xbd]);
        console.log(buffer1.toString());//大�
        let newBuffer = Buffer.concat([buffer1,buffer2]);//链接到一起
        console.log(newBuffer.toString());//大家好
    }
    {
        // 乱码解决 -> 内置模块string_decoder
        let { StringDecoder } = require("string_decoder");
        let decoder = new StringDecoder();
        let buffer1 = Buffer.from([0xe5,0xa4,0xa7,0xe5]);
        let buffer2 = Buffer.from([0xae,0xb6,0xe5,0xa5,0xbd]);
        let res1 = decoder.write(buffer1);
        let res2 = decoder.write(buffer2);
        console.log(res1);
        console.log(res2);
        console.log(res1,res2)
    }
}

stream.js 流

// stream 流; 可以把数据或文件,切割成很多个小份,依次进行传递
const fs = require("fs");
{
    let res = fs.readFileSync("1.txt");
    console.log(res.toString());
}
{
    let rs = fs.createReadStream("1.txt");//读流
    rs.on("data",chunk=>{
        console.log(chunk.toString());
    })
}
{
    // 创建一个65KB文件
    // let buffer = Buffer.alloc(64*1024);
    // fs.writeFile("64kb",buffer,err=>{
    //     if(err){
    //         return console.log(err);
    //     }
    //     console.log("写入成功");
    // });
}
{
    let rs = fs.createReadStream("1.txt");
    let num = 0;
    let str = "";
    rs.on("data",chunk=>{
        num++;
        str += chunk;
        console.log(num);
        // 流会把数据分成64kb的小文件传输;
    })
    rs.on("end",()=>{
        // 读取完毕
        console.log(str);
    })
}
{
    // 写入流
    let rs = fs.createReadStream("1.txt");
    let ws = fs.createWriteStream("2.txt");
    rs.pipe(ws);
    // 先读1.txt写入到2.txt里面去;
    // 和复制很相似
}