nodejs

进程是操作系统分配资源和调度任务的基本单位

操作系统分配资源 -> 由进程到线程

• 进程是操作系统分配资源的最小单位

• 线程是进程中的工作单元

nodejs 单进程 单线程 某个操作如果需要大量消耗cup的情况下 后续的操作都需要等待。

nodejs : 单线程 非阻塞I/O

优点：

1. 节约内存
2. 节约上下文切换的时间
3. 锁的问题 ，并发资源的处理（ java里面的概念 并发的时候对资源加锁限制其他进程对其的访问 ）

缺点 ：
一个线程崩了整个程序就挂了

多线程是如何实现的？
并不是真正在同一时间节点执行多个任务，而是通过非常快速的切换时间片来实现的。

浏览器里的UI线程跟js线程是公用一个线程的

webworker 不能改变js 单线程的本质 完全受主线程的控制 不能操作dom

堆heep 栈 stack

堆里面存 对象 栈里面存 变量

http请求是单独的线程

异步任务是成功后才方放到任务队列的

nodejs中的事件循环

LIBUV是 nodejs 中的异步I/O库

线程池加同步io 模拟异步io

什么叫同步和异步 ？

同步和异步关注的是消息的通知机制

去餐馆点饮料有 立马给你  ->同步 
      
     点餐没有  花时间做   -> 异步

什么叫阻塞和非阻塞？

等待取餐的时候什么都不做  阻塞   
等待取餐时候看玩儿游戏   非阻塞

阻塞和非阻塞是 程序在等待结果时的状态

同步和异步取决于被调用者
阻塞和非阻塞取决于调用者

node 文件名 > a.log正常的输出会写入a.log 错误的输出会写在控制台显示

node 文件名>a.log 2>&1错误的输出2重定向到1 中

console.assert(1==2,"error");断言

process.cwd() //当前工作目录

process.memoryUsage() //内存情况

console.log(process.memoryUsage());

//v8的内存量 1.7 G
{
    rss: 20340736,   // 常驻内存 
  heapTotal: 6062080,  // 堆内存的申请总量 
  heapUsed: 3696456,  // 已经使用的量 
  external: 8272      // 外部内存的使用量 
}

nextTick 和 setImmediate 区别和联系

• nextTick 把回调函数放在微任务队列
• setImmediate 把回调函数放在事件队列的尾部

function read(){
   
    setImmediate(function(){
   
        console.log(1)
    })
    process.nextTick(function(){
   
        console.log(2);
    })
}
read();

module

node 中的模块化遵循的是commonjs 规范

具体实现是会把每个模块放在一个立即执行函数中执行 ，这个函数包含5个参数

参数	详情
exports	当前模块的导出对象
require	require方法
module	当前模块
__filename	当前文件的绝对路径
__dirname	当前文件夹的绝对路径

require 的属性

参数	详情
resolve	只想知道模块的绝对路径,但又不想加载它 require.resolve
extensions	nodejs模块分三种 js json node { ‘.js’: [Function], ‘.json’: [Function], ‘.node’: [Function] },
main	入口文件
cache	缓存对象 模块在缓存的时候key值为导入模块的绝对路径

node中的进制

console.log(0b10100);  // 0b 表示二进制
console.log(0o24);  // 0o 表示八进制
console.log(0x14);  // 0x 表示十六进制
// 把十进制转成任意进制 
console.log((20).toString(2));
console.log(parseInt(0x4E07.toString(2)));

Buffer

//解决乱码  
let buffer9 = Buffer.from("刘夏江");
let buffer10 = buffer9.slice(0,5);
const {
    StringDecoder } = require("string_decoder");
sd = new StringDecoder; //专门用来解决乱码问题的 ；
console.log(sd.write(buffer10)); //刘
console.log(sd.write(buffer11)); //  夏江

合并buffer

const buffer1 = Buffer.from("夏");
const buffer2 = Buffer.from("江");
Buffer.concat1 = function(list,total = list.reduce((len,item)=>len+item.length,0)){
   
    if(list.length==1){
   
        return list[0];
    }
    let result = Buffer.alloc(total);
    let index = 0;
    for(let buf of list){
   
        for(let b of buf){
   
            if(index<=total){
   
                result[index++] = b;
            }else{
   
                return result;
            }
        }
    }
    return result;
}

const result = Buffer.concat1([buffer1,buffer2]);

console.log(result.toString());

fs

params	detail
fs.rename()	修改文件名
fs.truncate	截断文件内容
fs.unlink	删除文件
fs.rmdir	删除非空目录
fs.watchFile	监听文件改动
fs.statSync	获取文件信息
fs.open	打开文件
fs.close	关闭文件
fs.createReadStream	创建可读流
fs.createWriteStream	创建可写流

//异步读文件
fs.readFile('./1.txt',{
    encoding:"utf8",flag:"r"},function(error,data){
   
    if(error){
   
        console.log(error);
    }else{
   
        console.log(data);
    }
})
//异步写入文件
/* 
   flag:a    追加写入 
   mode      linux 权限位 
*/
fs.writeFile("./2.txt",'data',{
   encoding:"utf8",flag:"a",mode:0o666},function(error){
   
    if(error){
   
        console.log(error)
    }
})

//追加写入
fs.appendFile("./2.txt",'data1',function(error){
   
    if(error){
   
        console.log(error)
    }
})
//精确的控制读取的字节
//fd:file descript   文件描述符 
fs.open("./1.txt",'r',0o666,function(err,fd){
   
    let buffer = Buffer.alloc(4);
    // 读取文件部分内容
    fs.read(fd,buffer,1,3,1,function(err,bytesRead,buffe){
   
        console.log(buffe.toString());
    })
})
//监听控制台输入  标准输入
process.stdin.on("data",function(data){
   
    console.log(data);
})
//标准输出  consoel.log 对应 process.stdout.write
console.log('hellow');
process.stdout.write("hellow");
//错误输出  consoel.error 对应 process.stderr.write
console.error('hellow');
process.stderr.write("hellow");

边读边写

const fs = require("fs"); 
const BUFFER_SIZE = 6;
function copy(src,target) {
   
    const buffer = Buffer.alloc(BUFFER_SIZE)
    fs.open(src,'r',0o666,function(error,readFd){
   
        fs.open(target,'w',0o666,function(err,writeFd){
   
            !function next(){
   
                fs.read(readFd,buffer,0,BUFFER_SIZE,null,function(err1,bytesRead){
   
                    if(bytesRead>0){
   
                        fs.write(writeFd,buffer,0,bytesRead,null,next)
                    }
                })
            }()
        })
    })
}

copy('./2.txt','./1.txt');

创建目录 创建目录的时候其父目录必须是存在的

const fs = require("fs");
fs.mkdir('a',0o666,function(error){
   
    console.log(error);
})

递归删除非空目录

const fs = require("fs");
//递归删除非空目录   
function rmdir(dir){
   
    let files = fs.readdirSync(dir);
    files.forEach((file)=>{
   
        let current = dir+"/"+file;
        let child = fs.statSync(current);
        if(child.isDirectory()){
   
            rmdir(current);
        }else{
   
            fs.unlinkSync(current);
        }
    })
    fs.rmdirSync(dir)
}
rmdir('a');

fs.watchFile('./a.txt',(newStat,preStat)=>{
   
    if(Date.parse(preStat.ctime)==0){
   
        console.log("create");
    }else if(Date.parse(preStat.ctime)!==Date.parse(newStat.ctime)){
   
        console.log("update")
    }else{
   
        console.log('delete');
    }
})

const fs = require("fs");
//可读流
const rs = fs.createReadStream('./a.txt',{
   
    mode:0o666,
    encoding:"utf8",
    flags:"r",
    start:3,
    end:8,
    highWaterMark:3
});
rs.on("open",function(data){
   
    console.log('open');
});
rs.on("data",function(data){
   
    console.log(data);
    rs.pause();
    setTimeout(function(){
     
        rs.resume();
    },2000)
})
rs.on("end",function(data){
   
    console.log('end');
})

rs.on("error",function(data)