http、url模块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 引用http模块
const http = require('http');
/**
 * request 获取客户端传过来的信息
 * response 给浏览器响应信息
 */
http.createServer( (req, res) => {
  //http://127.0.0.1?name=zhangsan&age=20  想获取url传过来的name 和age
  
  // 响应头
  // 状态码200，文件类型是html，字符集utf-8
  res.writeHead(200, {'Content-Type': "text/html;charset='utf-8'"});
  res.write("<head><meta charset='UTF-8'></head>") //防止乱码
  
  // 获取url
  console.log(req.url);
  
  if(req.url!='/favicon.ico'){

        var userinfo=url.parse(req.url,true).query;
        
        console.log(`姓名：${userinfo.name}--年龄:${userinfo.age}`);
    }

  
  //结束响应
  res.end();
  // 输出一句话后结束响应
  // response.end('Hello World');

  // 接口
}).listen(3000);

console.log('Server running at http://127.0.0.1:3000/');

可使用node xx.js来启动程序，但是每次更新都要重启，因此可以使用supervisor工具来使其不用重启也能更新。它会不停的watch应用下的所有文件，一旦更新就会立刻重新部署

Commonjs

1
2
3
4
5
6
7
8
9
10
//暴露接口
//单独暴露一个方法
exports.xxx=obj;
//暴露一个集合的所有方法
model.exports=obj;

//获取接口
var request = require('./xxx/xx')
request.xxx.get();
request.get();

npm init --yes自定义生成模块之后可以通过该方法生成package.json来方便引用。

也可以使用es6的格式来导包，只是需要添加设置：在init生成了package.json之后，在其中加上“type”: “module”，然后就可以使用es6的样式来导包了。

fs–文件系统

fs.mkdir

  • 语法:fs.mkdir(path[, options], callback)
  • 同步:fs.mkdirSync()
  • 额外知识点:可以添加 recursive: true 参数，不管创建的目录 /tmp 和 /tmp/a 是否存在：
1
2
3
4
fs.mkdir('/tmp/a/apple', { recursive: true }, (err) => {
  if (err) throw err;
});
//由此创建的目录不论是否存在都不会报错,如果存在则不作任何操作.如果文件夹不存在则创建它.

fs.readdir

  • 语法:fs.readdir(path, callback)
  • 返回一个数组,其值是由该文件夹下每个文件的名称组成.
  • 它没有同步语法.

fs.writeFile

  • 语法:fs.writeFile(file, data[, options], callback)
  • 同步:fs.writeFileSync()
  • 它向指定文件写入数据,若文件不存在则创建它

fs.appendFile

  • 语法:fs.appendFile(path, data[, options], callback)
  • 同步:fs.appendFileSync()
  • 它向指定文件追加写入数据,若文件不存在则创建它

fs.readFile

  • 它有同步语法fs.readFileSync(path,(err,data)=>{})
  • 它作用是读取指定文件夹的数据
  • 它读取出来的是buffer数据
1
2
3
4
5
const fs = require('fs');
var data = fs.readFileSync("./tmp/num.txt");
console.log(data);
//文件数据:5646sadha
//<Buffer 35 36 34 36 73 61 64 68 61>
  • 它的作用是删除指定位置的文件
  • 文件夹内文件未完全删除不可删除文件夹
  • 它有同步语法

fs.rmdir

  • 它有同步语法
  • 它用于删除指定文件夹

fs.stat

  • 它主要用于判断是目录还是文件
1
2
3
4
5
6
7
8
9
const fs = require('fs');
fs.stat('./html', (err, data) => {
    if (err) {
        console.log(err);
        return;
    }
    console.log(`是文件:${data.isFile()}`);//false
    console.log(`是目录:${data.isDirectory()}`);//true
});

fs.rename

  • 作用1:用于给文件或文件夹更名
  • 作用2:用于转移文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const fs = require('fs');
fs.rename("./html", "./html5", (err) => {
    if (err) {
        console.log(err);
        return;
    }
    console.log('重命名成功');
});
const fs = require('fs');
fs.rename('./index.html', './html5/index.html', (err) => {
    if (err) {
        console.log(err);
        return;
    }
    console.log('转移文件成功');
});

mkdirp工具实现类似于linux中的mkdir -p递归创建目录及其子目录。

1
2
3
4
5
const mkdirp = require('mkdirp')

// return value is a Promise resolving to the first directory created
mkdirp('/tmp/foo/bar/baz').then(made =>
console.log(`made directories, starting with ${made}`))

fs.createReadstream()

从文件流中读取数据

1
2
3
4
5
6
7
8
9
10
11
12
13
const fs = require('fs') 
var fileReadStream = fs.createReadStream('data.json') let count=0; 
var str=''; 
fileReadStream.on('data', (chunk) => { 
  console.log(`${ ++count } 接收到：${chunk.length}`); 		str+=chunk
})
fileReadStream.on('end', () => { 
  console.log('--- 结束 ---'); 
  console.log(count); 
  console.log(str); 
})
fileReadStream.on('error', (error) => { 								console.log(error) 
})

Fs.createWriteStream()

写入文件

1
var fs = require("fs"); var data = '我是从数据库获取的数据，我要保存起来'; // 创建一个可以写入的流，写入到文件 output.txt 中 var writerStream = fs.createWriteStream('output.txt'); // 使用 utf8 编码写入数据 writerStream.write(data,'UTF8'); // 标记文件末尾 writerStream.end(); // 处理流事件 --> finish 事件 writerStream.on('finish', function() { /*finish - 所有数据已被写入到底层系统时触发。*/   console.log("写入完成。"); }); writerStream.on('error', function(err){ 								console.log(err.stack); }); console.log("程序执行完毕");

管道流

当要传输大文件的时候用到的

1
var fs = require("fs"); // 创建一个可读流 var readerStream = fs.createReadStream('input.txt'); // 创建一个可写流 var writerStream = fs.createWriteStream('output.txt'); // 管道读写操作 // 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中 readerStream.pipe(writerStream); console.log("程序执行完毕");

callback的异步处理

1
2
3
4
5
6
7
8
9
10
function getDate(callback) {
  setTimeout(function() {
    var name = 'hhh';
    callback(name)
  }, 1000)
}

getDate(n) => {
  console.log(n)
}

promise的异步处理

1
2
3
4
5
6
7
8
9
var p = new Promise(function(resolve, reject) =>{
                    setTimeout(function() {
    var name = 'hhh';
    callback(name)
  }, 1000)
                    })
p.then(data => {
  console.log(data)
})

async、await处理异步方法

  • async 是让方法变成异步。
  • await 是等待异步方法执行完成。

使用async之后会将方法的返回值变为Promise。

1
2
3
4
5
async function test(){   
    return '您好nodejs';
}

console.log(test());  //  Promise { '您好nodejs' }

用await虽然可以取出async中返回的值，但是也要在async方法中。

对于await的使用，根据对象的不同会执行不同的操作。

  • 如果不是 promise , await会阻塞后面的代码，先执行async外面的同步代码，同步代码执行完，再回到async内部，把这个非promise的东西，作为await表达式的结果。
  • 如果它等到的是一个 promise 对象，await 也会暂停async后面的代码，先执行async外面的同步代码，等着 Promise 对象 fulfilled，然后把 resolve 的参数作为 await 表达式的运算结果。
1
2
3
4
5
6
// 这样会错
async function test(){   
    return '您好nodejs';
}

console.log(await test());

正确使用形式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
async function test(){  
    return '您好nodejs';
}

async function main(){

    var data=await test();  //获取异步方法里面的数据

    console.log(data);
}
main();

// 另一个实例
async function test(){  
   return new Promise((resolve,reject)=>{
        setTimeout(function(){
            var name='张三 222';   
            resolve(name);
        },1000);
   })

}

async function main(){
    var data=await test();  //获取异步方法里面的数据
    console.log(data);
}
main();