Nodejs 学习笔记-相片整理Demo（二）

　　好吧，开始代码！

　　确认一下需要哪些模块，由于只需要进行文件复制，那么基本用fs和util就行了。那就先用这两个试试，不够再说。

　　接下来需要定义一些要用到的变量，具体是什么，看注释吧。

var fs = require('fs'),
    util = require('util'),
    fromPath = 'G:\相片备份\相片\日常', //基础目录
    toPath = 'L:\相片备份\相片\日常',//备份目录
    copy = {}, //命名空间
    fileCount = 0, //总数
    dirCount = 0,  //文件夹数量
    startTime,     //开始时间
    copyFormat = ['png', 'jpg', 'gif', 'tif', '3gp', 'mpg', 'thm', 'mov', 'mp4', 'vob', 'ifo', 'bup', 'avi', 'bmp', 'zip', 'rar'],//复制的格式
    pathSpliter = '\', //路径分隔符
    totalCount = 0, //总数
    copyCount = 0,  //复制数量
    uncopyCount = 0;//没有复制的数量

　　定义好变量和引用的模块，下面开始写功能函数。

　　1.要检测一下两个路径是否存在，如果要复制到的路径不存在，就要创建一下。

//检测路径
copy.checkPath = function (path, callback) {
    fs.exists(path,
        function (exist) {
            if (exist) {
                console.log('路径存在！-' + path);
            } else {
                console.log('路径不存在！-' + path);
            }
            if (callback) {
                callback(exist);
            }
        });
};
//检测源路径
copy.checkFromPath = function () {
    startTime = new Date();
    copy.checkPath(fromPath,
        function (exist) {
            if (exist) {
                copy.checkToPath();
            } else {
                console.log('复制路径不存在，检查一下。');
            }
        });
};
//创建路径
copy.createPath = function (path, callback) {
    fs.mkdir(path, '0777',
        function (err, result) {
            //console.log('创建路径-' +    path);
            callback();
        });
};
//复制路径
copy.checkToPath = function () {
    copy.checkPath(toPath,
        function (exist) {
            if (exist) {
                copy.readPath(fromPath, copy.fs);
            } else {
                copy.createPath(toPath,
                    function () {
                        copy.readPath(fromPath, copy.fs);
                    });
            }
        });
};

　　2.路径准备完毕了，需要开始了解一下都有哪些文件需要复制了，然后根据规则逐条复制吧。

//数据文件系统
copy.fs = {};
copy.readPath = function (path, fss) {
    fs.readdir(path,
        function (err, files) {
            if (err) console.log(err);
            else {
                dirCount++;
                copy.fillFilesTofs(path, files, fss);
            }
        });
};
//填充文件夹结构
copy.fillFilesTofs = function (path, files, fss) {
    fss['path'] = path;
    fss['children'] = files;
    copy.copyFiles(fss);
};
copy.getPathByTime = function (date, format) {
    var result = {
        path: '',
        filename: ''
    };
    var paths = [];
    paths.push(toPath);
    paths.push(date.getFullYear());
    var month = date.getMonth() + 1;
    month = month.toString();
    if (month.length == 1) {
        month = '0' + month;

    }
    paths.push(month);
    var day = date.getDate();
    day = day.toString();
    if (day.length == 1) {
        day = '0' + day;

    }
    paths.push(day);
    //paths.push(date.getTime()    + '.' +    format);
    var hour = date.getHours();
    hour = hour.toString();
    if (hour.length == 1) {
        hour = '0' + hour;

    }
    var minutes = date.getMinutes();
    minutes = minutes.toString();
    if (minutes.length == 1) {
        minutes = '0' + minutes;

    }
    var seconds = date.getSeconds();
    seconds = seconds.toString();
    if (seconds.length == 1) {
        seconds = '0' + seconds;

    }
    return {
        path: paths.join(pathSpliter),
        filename: hour + minutes + seconds + '.' + format
    };

};
//复制文件夹目录
copy.copyFiles = function (fss) {
    if (fss.children.length > 0) {
        var fullpath = fss.path + pathSpliter + fss.children[0];
        fs.stat(fullpath,
            function (err, stat) {
                if (err) throw err;
                else {
                    if (stat.isFile()) {
                        var format = fss.children[0].split('.');
                        format = format[format.length - 1];
                        if (format && copyFormat.indexOf(format.toString().toLowerCase()) >= 0) {
                            format = format.toString().toLowerCase();
                            var cTime = stat.mtime;
                            var newPath = copy.getPathByTime(cTime, format);
                            var cp = function () {
                                copy.copyFile(fullpath, newPath.path + pathSpliter + newPath.filename, stat,
                                    function () {
                                        fss.children.shift();
                                        copy.copyFiles(fss);
                                    });
                            };
                            fs.exists(newPath.path,
                                function (exist) {
                                    if (exist) {
                                        cp();
                                    }
                                    else {
                                        copy.mkdir(newPath.path, 2,
                                            function () {
                                                cp();
                                            });
                                    }
                                });
                        } else {
                            console.log('没有复制文件-' + fullpath);
                            console.log(format.toString().toLowerCase());
                            fss.children.shift();
                            copy.copyFiles(fss);
                        }
                    } else {
                        fss.children[0] = {
                            'path': fullpath,
                            'children': [],
                            'parentPath': fss.path
                        };
                        copy.readPath(fullpath, fss.children[0]);
                    }
                    ;
                }
            });

    } else {
        if (fss.parentPath) {
            var parent = copy.getParent(fss.parentPath, copy.fs, 0);
            if (parent) {
                parent.children.shift();
                copy.copyFiles(parent);
            }
        }
        ;
    }

};
//创建文件夹
copy.mkdir = function (path, deep, callback) {
    var paths = path.split(pathSpliter);
    var p = [];
    if (deep == paths.length + 1) {
        callback();
    } else {
        for (var i = 0; i < deep; i++) {
            p.push(paths[i]);
        }
        fs.exists(p.join(pathSpliter),
            function (exist) {
                if (exist) {
                    copy.mkdir(path, deep + 1, callback);
                } else {
                    fs.mkdir(p.join(pathSpliter), '0777',
                        function () {
                            copy.mkdir(path, deep + 1, callback);

                        });
                }
            });
    }
};
//复制文件
copy.copyFile = function (fPath, tPath, fStat, callback) {
    fs.exists(tPath,
        function (exist) {
            if (exist) {
                fs.stat(tPath,
                    function (err, stat) {
                        if (err) throw err;
                        if (stat.ct == fStat.ct && stat.size == fStat.size) {
                            callback();
                        } else {
                            var nTpath = tPath.split('.')[0] + '0.' + tPath.split('.')[1];
                            copy.copyFile(fPath, nTpath, fStat, callback);

                        }
                    });
            } else {
                var readStream = fs.createReadStream(fPath);
                var writeStream = fs.createWriteStream(tPath);
                console.log('copyFile-' + fPath + '-' + tPath + exist);

                util.pump(readStream, writeStream,
                    function () {
                        fileCount++;
                        callback();
                    });

            }

        });
};
//获取父节点
copy.getParent = function (path, fss, deep) {
    if (fss.path == path) {
        return fss;
    } else {
        for (var i = 0; i < fss.children.length; i++) {
            var p = copy.getParent(path, fss.children[i], deep++);
            if (p) {
                return p;
            }
        }
        return null;
    }
};