Node基础初始(1)

node

buffer缓冲区

// let buf = new Buffer(5);
// let buf = new Buffer('abc');//<Buffer 61 62 63>  97 98 99
// let buf = new Buffer([1,2,3]);
// let buf1 = new Buffer(buf);
// console.log(buf1);

不推荐new的方式产生实例，推荐静态方法生成实例

// let buf = Buffer.alloc(5);//<Buffer 00 00 00 00 00>
// console.log(buf);

// let buf = Buffer.from('abc');
// console.log(buf);

• byteLength

// const str = '\u00bd + \u00bc = \u00be';
// let ret = Buffer.byteLength(str,'ascii');//统计特定编码下字符串对应的字节数
// console.log(ret,str);

• isBuffer

// let buf = Buffer.alloc(5);
// console.log(Buffer.isBuffer(buf));//判断参数中的数据是否为Buffer实例
// console.log(Buffer.isBuffer('abc'));

• isEncoding

// console.log(Buffer.isEncoding('base64'));//判断Buffer是否支持该编码

• write

// buf.write(string[, offset[, length]][, encoding])
/*
    参数一：要写入buf的字符串
    参数二：开始写的位置
    参数三：写入的长度
    参数四：编码形式
*/
// let buf = Buffer.alloc(5);
// buf.write('abc',2,2,'utf8');//向Buffer实例中写入数据
// console.log(buf);

• equals

// let buf1 = Buffer.from('abc');
// let buf2 = Buffer.from('abcd');
// console.log(buf1.equals(buf2));//判断两个Buffer实例是否相等

• indexOf

// const buf = Buffer.from('this is a buffer');
// console.log(buf.indexOf('buffer'));//检索特定字符串在整个Buffer中的位置

• slice

let buf = Buffer.from('abcde');
console.log(buf.slice(2,5));//截取Buffer实例的一部分，生成一个新的Buffer实例

path

• basename

// 截取路径中的文件名
// let ret = path.basename('/foo/bar/baz/asdf/quux.html');
// let ret = path.basename('/foo/bar/baz/asdf/quux.html', '.html');//省略文件格式后缀
// console.log(ret);

• parse

// parse把字符串形式的路径转化为对象形式
// let obj = path.parse('/home/user/dir/file.txt');
// console.log(obj.base);
// { root: '/',
//   dir: '/home/user/dir',
//   base: 'file.txt',
//   ext: '.txt',
//   name: 'file' 
// }

• format

// format把对象形式的路径转化为字符串形式
// let str = path.format(obj);
// console.log(str);//  /home/user/dir\file.txt

• normalize

// normalize标准化路径
// let str = path.normalize('C:\\temp\\\\foo\\bar\\..\\');
// console.log(str);// C:\temp\foo\

• join(常用)

// join用来拼接路径
// let str = path.join('/foo', 'bar', 'baz/asdf', 'quux', '..');
// let str = path.join(__dirname,'./README.md');//C:\Users\www\Desktop\Nodejs\代码\nodejs\day03\README.md
// console.log(str);// \foo\bar\baz\asdf

• relative

// 计算相对路径
// let str = path.relative('/data/orandea/test/aaa', '/data/orandea/impl/bbb');
// console.log(str);// ..\..\impl\bbb

• resolve

// 解析绝对路径
// let str = path.resolve('/foo/bar', '/tmp/file/');
// console.log(str);//C:\tmp\file

file

require 依赖请求

const path = require('path');
const fs = require('fs');

stat

// 查看文件的状态信息（异步操作）
fs.stat(path.join(__dirname,'./data.txt'),(err,stats)=>{
    console.log(err);
    // console.log(stats);
    // console.log('atime:访问时间' + stats.atime);
    // console.log('mtime:内容修改时间' + stats.mtime);
    // console.log('ctime:文件状态修改时间' + stats.ctime);
    // console.log('btime:创建时间' + stats.birthtime);
    console.log(stats.isFile());//判断是否为文件
    console.log(stats.isDirectory());//判断是否为路径
    console.log(2);
});
console.log(3);

由于提到了异步操作
    浏览器中的异步操作：
    1、定时函数(达到延时事件)
    2、事件函数(特定的事件触发)
    3、ajax回调函数(服务器数据相应的时候)

    异步任务触发条件：
    1、主线程空闲
    2、满足任务的触发条件

    js的运行是单线程的

    单线程+事件队列


// console.log(11);
// // 同步操作
// let ret = fs.statSync(path.join(__dirname,'data.txt'));
// console.log(ret);
// console.log(333);

stats 状态

 fs.stat(path.join(__dirname,'data.txt'),(err,stats) => {
     console.log(stats);
     if(!err && stats.isFile()){
         console.log('该文件存在');
     }else{
         console.log('该文件不存在');
     }
 });

文件操作

open：

/*
    文件操作
    fs.open(path, flags[, mode], callback)
    path  文件的路径
    flags  打开文件的方式   r-- w --
    mode  Linux平台有效，可以控制文件的读、写、可执行 777，参数是可选的
    callback 回调函数（err,fd）
*/

fd：

// fs.open(path.join(__dirname,'./data.txt'),'r',(err,fd) => {
//     // fd file discriptor 文件描述符，通过fd可以操作文件，默认从3开始，打开多次接着累加
//     if(err){
//         console.log(err);
//         return;
//     }
//     console.log(err,fd);
// });

// 同步方法的返回值表示fd
let ret = fs.openSync(path.join(__dirname,'./data.txt'),'r');
console.log(ret);

read:

    文件读操作
    fs.read(fd, buffer, offset, length, position, callback)
    fd 文件描述符
    buffer 读取的数据放到buffer中
    offset 读取的数据从buffer的第几个位置开始写
    length 读取文件中数据的字节数量
    position 从文件的什么位置开始读
    callback 回调函数（err,bytes,buffer）

const path = require('path');
const fs = require('fs');

// fs.open(path.join(__dirname,'./data.txt'),'r',(err,fd) => {
//     let buf = Buffer.alloc(5);
//     fs.read(fd,buf,1,3,null,(err,bytes,buffer) => {
//         console.log(err,bytes,buffer);//bytes表示读取的字节数量
//         console.log(buf);//读取的文件内容
//         console.log(buf == buffer);//buffer和read参数中的buf是同一份数据
//     });
// });

//同步操作
let fd = fs.openSync(path.join(__dirname,'./data.txt'),'r'); 
let buf = Buffer.alloc(5);
let ret = fs.readSync(fd,buf,0,4);
console.log(ret,buf);

write:

    文件写操作(浏览器中的js和Node.js中的js语法上都不支持方法重载，但是可以在定义函数时，根据参数的个数，和函数的类型进行判断，从而根据实参形式上的差别来区分实际的调用形式)
    fs.write(fd, buffer, offset, length[, position], callback)
    fs.writeSync(fd, buffer, offset, length[, position])

    fs.write(fd, data[, position[, encoding]], callback)
    fs.writeSync(fd, data[, position[, encoding]])

const path = require('path');
const fs = require('fs');
// 方法重载（方法名称相同，但是参数的个数不同，参数的类型不同）
// fs.open(path.join(__dirname, './data.txt'), 'w', (err, fd) => {
//     let buf = Buffer.from('中国');
//     // written指的是字节数量，而不是字符数量
//     fs.write(fd,buf,0,6,(err,written,buffer) => {
//         console.log(err,written,buffer);
//         console.log(buf === buffer);
//     });
// });

// fs.open(path.join(__dirname, './data.txt'), 'w', (err, fd) => {
//     // let buf = Buffer.from('中国');
//     fs.write(fd,'程序员',(err,written,str) => {
//         console.log(err,written,str);
//     });
// });

//tongbu
// let fd = fs.openSync(path.join(__dirname, './data.txt'), 'w');
// let buf = Buffer.from('中国');
// // let ret = fs.writeSync(fd,buf,0,6,null);
// let ret = fs.writeSync(fd,'程序员');
// console.log(ret);

readFile:

   文件读操作
    fs.readFile(file[, options], callback)
    file 表示文件名称或者文件描述符
    options 可以是字符串形式，表示编码；可以是对象形式（encoding,flag）
    callback 回调函数（err,data 实际读取的数据）

    fs.readFileSync(file[, options])

// 第二个参数指定编码，回调函数中的data是字符串，不指定的是Buffer
// fs.readFile(path.join(__dirname,'./data.txt'),(err,data)=>{
//     console.log(data.toString());
// });

// fs.readFile(path.join(__dirname,'./data.txt'),'utf8',(err,data)=>{
//     console.log(data);
// });

// let content = fs.readFileSync(path.join(__dirname,'./data.txt'),'utf8');
let content = fs.readFileSync(path.join(__dirname,'./data.txt'));
console.log(content);

writeFile:

    文件写操作
    fs.writeFile(file, data[, options], callback)
    data 写入的数据

    fs.writeFileSync(file, data[, options])

const path = require('path');
const fs = require('fs');

// fs.writeFile(path.join(__dirname,'./data.txt'),'hi',(err)=>{
//     console.log(err);
// });

fs.writeFileSync(path.join(__dirname,'./data.txt'),'中国');

appendFile:

   文件内容追加
    fs.appendFile(file, data[, options], callback)

    fs.appendFileSync(file, data[, options])

const path = require('path');
const fs = require('fs');

// fs.appendFile(path.join(__dirname,'./data.txt'),'程序员',(err)=>{
//     console.log(err);
// });

fs.appendFileSync(path.join(__dirname,'./data.txt'),'程序员');