定时器，同步API和异步API，文件系统模块，文件流

七、定时器

提供一组全局函数，可以直接调用
1、一次性定时器

开启
var timer = setTimeout（回调函数，间隔时间的单位是毫秒）
当间隔时间到了，会自动调用一次回调函数，间隔时间单位为毫秒
清除
clearTimeout（timer）

//开启一次性定时器
//setTimeout(回调函数，间隔时间)
//当间隔时间到了，会自动调用回调函数
//间隔时间 单位是毫秒
var timer=setTimeout(function(){
console.log(‘boom!’)
},3000)

                                                              clearTimeout(timer)

2、周期性定时器

开启
var timer = setInterval（回调函数，间隔时间）
每隔一段时间，会自动调用一次回调函数
清除
clearIntval（timer）

var timer=setInterval(function(){
console.log(‘起床了’)
},3000)

3、立即执行定时器
开启
var timer=setImmediate（回调函数）
清除
clearImmediate(timer)
开启
process.nextTick（回调函数） 只有开启，没有清除

同步执行：在主程序中执行就是同步，会阻止主程序后续代码的执行
异步执行：在主程序后的事件队列执行就是异步，不阻止主程序后续代码执行

所有定时器都属于异步执行

//立即执行定时器
//开启
setImmediate(function(){console.log(1)})

//执行顺序
console.log(1)
setImmediate(function(){console.log(2)})
console.log(3)
//1 3 2

//执行顺序
console.log(1)
//立即执行定时器
setImmediate(function(){console.log(2)})
//另一个立即执行定时器
process.nextTick(function(){console.log(3)})
console.log(4)
//1 4 3 2

//练习：开启周期性计时器，每隔3秒钟打印‘hello’,打印3次后清除定时器
//声明变量，用于计数
var count=0
//开启
var timer=setInterval(function(){
console.log(‘hello’)
//打印一次，记录一次
count++
//每次记录，判断，如果次数为3，则清除定时器
if (count==3)
{
clearInterval(timer)
}
},3000)

八、同步API和异步API

同步API：在主程序执行，会阻止后续代码的执行，最终通过返回值获取结果
       如何解决
异步API：在一个独立的线程执行，不会阻止主程序后续代码的执行，最终通过回调函数获取结果

//同步API
var s=fs.statSync(‘…/02day’)
//查看是否为文件
console.log(s.isFile()) //false
//查看是否为目录
console.log(s.isDirectory()) //true

//针对耗时的操作，采取异步API
//异步API会把结果放到回调函数的参数中 //主程序执行完，会自动执行事件队列，拿到了异步API结果
fs.stat(‘…/02day/06_yimer.js’,function(err,s){
//err 失败的结果
//如果有错误，就抛出错误
if (err)
{
//自定义错误
throw err //Error: ENOENT: no such file or directory
}
//s 成功的结果
console.log(s)
console.log(‘2’)
})
console.log(‘1’)
//执行顺序 1 2

九，文件系统模块（ fs ）

用于操作服务器端文件，不是本地文件

1、产看文件状态
statSyns（文件路径）/ stat（文件路径，回调函数 ）
isFile（） 是否为文件
isDirectory（） 是否为目录

//引入系统模块
//fs是核心模块，就是官方提供的模块，去自动到Node.js安装目录下寻找
const fs=require(‘fs’)
//console.log(fs)
//查看06_yimer.js文件
//Sync 同步
var s=fs.statSync(‘…/02day/06_yimer.js’)
//console.log(s)
//产看是否为文件
console.log(s.isFile()) //true
//查看是否为目录
console.log(s.isDirectory()) //false

var s=fs.statSync(‘…/02day’)
//查看是否为文件
console.log(s.isFile()) //false
//查看是否为目录
console.log(s.isDirectory()) //true

2、清空写入文件
writeFileSync（文件的路径，写入的数据）/ writeFile（文件路径，写入的数据，回调函数）
如果文件不存在，先创建文件然后写入数据
如果文件存在，先清空文件按的内容，再写入数据

const fs=require(‘fs’)
//写入文件
//往01.txt中写入用户名‘tao’
//同步
//如果文件不存在，会在同级目录下自动创建文件
//如果文件存在，会清空内容再写入
fs.writeFileSync(‘./1.txt’,‘tao’)

//异步
fs.writeFile(‘./2.txt’,‘楠姐’,function(err){
//err 可能产生的错误
if (err)
{
throw err
}
//成功的结果是把数据写入，不再需要第二个参数
//只有成功的结果是一个值，才会需要第二个参数
})

3、追加写入文件
appendFileSync（文件路径，写入数据） / appendFile（文件的路径，写入数据，回调函数）
如果文件不存在，先创建文件然后写入数据
如果文件存在，先清空文件按的内容，再写入数据

//追加写入
//练习：使用同步方法往3.txt写入一个值
const fs=require(‘fs’)
fs.appendFileSync(‘3.txt’,‘我是大聪明’)
//练习：使用异步方法往4.txt写入一个值
fs.appendFile(‘4.txt’,‘美少女战术’,function(err){
if (err)
{
throw err
}
})

//练习：创建数组，保存一组姓名，遍历数组获取每一个姓名，将姓名写入到文件stu.txt中，使用异步方法（观察文件中姓名的顺序）
const fs=require(‘fs’)
var arr=[‘小王’,‘张三’,‘李四’,‘王五’,‘马哥’]
for (var i=0;i<arr.length ;i++ )
{
console.log(arr[i])
fs.appendFile(‘./stu.txt’,arr[i]+‘\n’,function(err){
if (err)
{
throw err
}
})
}
//名字排列顺序出现错乱

4、读取文件
readFileSync（文件路径）/ readFile（文件路径，回调函数）
读取到的格式为Buffer

const fs=require(‘fs’)
var s=fs.readFileSync(‘./2.txt’)
//格式为Buffer
console.log(s.toString())

//练习：使用异步方法读取
fs.readFile(‘./2.txt’,function(err,s){
if (err)
{throw err
}
console.log(s.toString())
})
console.log(s) //<Buffer e6 a5 a0 e5 a7 90>

5、删除文件
unlinkSync（文件路径）/ unlink（文件路径，回调函数）

const fs=require(‘fs’)
var s=fs.readFileSync(‘./2.txt’)
//格式为Buffer
console.log(s.toString())
fs.readFile(‘./2.txt’,function(err,s){
if (err)
{throw err
}
console.log(s.toString())
})
console.log(s) //<Buffer e6 a5 a0 e5 a7 90>

fs.unlinkSync(‘1.txt’)

fs.unlink(‘2.txt’,(err,s)=>{
if (err)
{throw err
}
})

6、拷贝文件
copyFileSync（源文件路径，目标文件路径）/ copyFile（源文件路径，目标文件路径，回调函数）

//拷贝文件
const fs=require(‘fs’)
fs.copyFileSync(‘./4.txt’,‘./5.txt’)

十、文件流

流：可以把一个文件分成多端
       createReadStream（）     创建可读取的文件流
       createWriteStream（）     创建可写入的文件流
       pipe（）     管道，可以将读取的流添加到写入流
       on（事件名称，回调函数）         

//引入fa文件
const fs=require(‘fs’)
//以流的方式读取文件，分为很多段
var rs=fs.createReadStream(‘./3.png’)

//获取读取的每一段
//添加事件：监听是否有数据流入到内存
//on() 用来添加事件，监听某一个动作
//‘data’ 固定的字符串形式，监听到数据流如，一旦流入会自动调用回调函数

rs.on(‘data’,=>{
//参数c 表示每次读取到的一段数据
console.log
})
//添加事件：监听是否读取结束
//'end’是固定的字符串，监听读取结束
rs.on(‘end’,(a)=>{
console.log(‘读取结束’)
})

//打桩，看是同步还是异步
console.log(1) //1先执行，为异步
//引入fa文件
const fs=require(‘fs’)
//以流的方式读取文件，分为很多段
var rs=fs.createReadStream(‘./3.png’)
//创建写入流，以流的方式写入文件
var ws=fs.createWriteStream(‘./4.png’)
//将读取的流通过管道添加到写入流
rs.pipe(ws)