妙味课堂——NodeJS分享视频

var a = 100;
console.log(a); //100
console.log(global.a); //undefined 因为这个a是定义在模块下面的变量，不属于全局变量

var a = 100;
console.log(a); //100
global.a = 200;
console.log(a); //还是100
console.log(global.a); //200

//一些看似全局的属于当前模块的变量

//__filename 当前文件被解析后的绝对路径；其实这个变量是属于当前模块的
console.log(__filename);

//require("模块路径");

//require('./2.js');

//当前模块在硬盘当中的绝对路径
require('b:/录制视频/nodejs/课件/module/2.js');
//跟当前模块的相对路径
require('./2.js'); //在nodejs中千万不能写成 require('2.js') 因为它将会去加载node中的核心模块，或者是node_modules目录下的模块

//当前模块为4
//在模块5中为global对象添加一个属性 global.a = 100;
require('./5');
console.log(a); //100

//5模块
var a = 100;
module.exports.a = a;

//4模块
//require('./5'); //返回值就是被加载模块当中的exports
var m5 = require('./5');
console.log(m5.a); //100

//5模块
var a = 100;

//console.log(module.exports === exports); //true
exports.a = a;

module.exports = [1, 2, 3]; //直接这样对module.exports进行操作，这时候exports和module.exports的指向关系已经断开了

exports.a = 200; //这时候这个a已经加不到module.exports中了，所以在其他模块中引用它也引用不到了，因为这个模块的返回值已经变成了[1, 2, 3]

//__filename：返回当前模块文件解析后的绝对路径，该属性并非全局，而是模块作用域下的
console.log(global.__filename); //undefined
console.log(__filename);

//__dirname：返回当前模块文件所在目录解析后的绝对路径，该属性也并非全局，而是模块作用域下的
console.log(__dirname);

var d = new Date();
var arr = new Array(1, 2, 3);

//命令行形式的时钟
setInterval(function(){
	var d = new Date();
	console.log('现在是：' + d.getFullYear() + '年' + (d.getMonth()+1) + '月' + d.getDate() + '日' + d.getHours() + " : " + d.getMinutes() + ' : ' + d.getSeconds());
}, 1000);

//process全局对象，通过这个对象提供的属性和方法，使我们可以对当前运行的程序的进程进行访问

console.log(process);
console.log(global.process);

//argv: - Array 一组包含命令行参数的数组，第一个元素是node，第二个元素是js文件的名称，接下来的元素依次是命令行传入的参数
//execPath: - 开启当前进程的绝对路径
//env: - 返回用户环境信息

console.log(process.argv);
console.log(process.env);

//version: - 返回版本信息
//versions: - 返回node以及node依赖包版本信息
//pid: - 当前进程的pid
//title: - 当前进程的显示名称（Getter/Setter）
//arch: - 返回当前CPU处理器框架 arm/ia32/x64
//platform: - 返回当前操作系统平台
//cwd(): - 返回当前进程的工作目录
//chdir(directory): - 改变当前进程的工作目录
//memoryUsage(): - 返回node进程的内存使用情况，单位是byte
//exit(code): - 退出
//kill(pid): - 向进程发送信息

//process对象的stdin（标准输入流）和stdout（标准输出流）

process.stdout.write('hello');
function log(data){
	process.stdout.write(data);
}
log('你好');

//默认情况下，输入流是关闭的，要监听处理输入流数据，首先要开启输入流
process.stdin.resume();
//用于监听用户的输入数据
process.stdin.on('data', function(chunk){
	console.log('用户输入了: ' + chunk);
});

process.stdin.resume();
var a;
var b;
process.stdout.write('请输入a的值：');
process.stdin.on('data', function(chunk){
	if (!a){
		a = Number(chunk);
		process.stdout.write('请输入b的值：');
	} else {
		b = Number(chunk);
		process.stdout.write('结果是：'+ (a + b));
	}
})

//当我们为一个Buffer对象分配空间大小之后，其长度是固定的，不能更改
var bf = new Buffer(5);
console.log(bf);
bf[6] = 10;
console.log(bf); //bf没有任何变化
bf[1] = 2;
console.log(bf); //bf的第二个位置上的字符会变成02

var bf = new Buffer([1, 2, 3]);
console.log(bf);
bf[10] = 10;
console.log(bf); //bf也没有变化，因为bf的长度没有改变。bf只要初始化了，那么它的长度就是没有变化的

var bf = new Buffer('miaov', 'utf-8');
console.log(bf);

for(var i=0; i<bf.length; i++){ //Buffer的length是字节长度，而不是字符长度
	//console.log(bf[i]);
	//console.log(bf[i].toString(16));
	console.log(String.fromCharCode(bf[i]));
}

var str1 = 'miaov';
var bf1 = new Buffer(str1);
console.log(str1.length); //5
console.log(bf1.length); //5

var str2 = '妙味';
var bf2 = new Buffer(str2);
console.log(str2.length); //2
console.log(bf2.length); //6

var bf = new Buffer('miaov');
console.log(bf.toString()); //miaov
console.log(bf.toString('utf-8', 1, 3)); //ia 

var bf2 = new Buffer('妙味');
console.log(bf2);
console.log(bf2.toString('utf-8', 1)); //乱码

console.log(bf.toJSON()); //{type: 'Buffer', data: [109, 105, 97, 111, 118]}

var bf = new Buffer('miaov');
var bf2 = bf.slice();
console.log(bf);
console.log(bf2);
var bf3 = bf.slice(2,4);
console.log(bf3);

bf3[0] = 2;
console.log(bf3); //第0位变成了02
console.log(bf); //bf相应位置也变成了02

var bf4 = new Buffer(10);
bf.copy(bf4);
console.log(bf4);
bf4[0] = 2;
console.log(bf4); //发生了改变
console.log(bf); //bf没有受到影响

var bf5 = new Buffer(10);
bf.copy(bf5, 1, 2, 4);
console.log(bf5);

console.log(Buffer.isEncoding('utf-8')); //true
console.log(Buffer.isEncoding('gbk')); //false
console.log(Buffer.isEncoding('hex')); //true

var arr = [1, 2, 3];
var bf = new Buffer(10);
console.log(Buffer.isBuffer(arr)); //false
console.log(Buffer.isBuffer(bf)); //true

var str1 = '妙味';
console.log(str1.length); //2
console.log(Buffer.byteLength(str1)); //6
console.log(Buffer.byteLength(str1, 'ascii')); //2

var str1 = 'miaov';
var str2 = '妙味';
var list = [new Buffer(str1), new Buffer(str2)];
console.log(list); //list是一个字节数组
var bf = Buffer.concat(list, 11);
console.log(bf);

process.stdout.write('请输入内容：');
process.stdin.resume();
process.stdin.on('data', function(chunk){
	console.log(chunk); //这个chunk其实是个buffer对象
	console.log(chunk.toString());
	console.log('输入的内容是：'+ chunk); //内部Buffer自动拼接为string，不需要手动显式地toString了
});

var fs = require('fs');
/*
 * fs.open(path, flags, [mode], callback)
 * path: 要打开文件的路径
 * flags: 打开文件的方式 读/写
 * mode: 设置文件的模式 读/写/执行 4/2/1
 * callback: 回调
 *     err: 文件打开失败的错误保存在err里面，如果成功，err为null
 *     fd: 被打开文件的标识，和定时器都点像
 */

fs.open('1.txt', 'r', function(err, fd){
	//console.log(err);
	//console.log(fd);

	if(err){
		console.log('文件打开失败');
	} else {
		console.log('文件打开成功');
		console.log(fd); 
	}
})

fs.open('1.txt', 'r', function(err,fd){
	console.log(fd); //会发现这个fd跟上面的不一样了，这个地方的fd累加了
})

var fs = require('fs');

//异步方式处理
fs.open('1.txt', 'r', function(err, fd){
	console.log(fd);
})
console.log('ok');

//同步方式
var fd = fs.openSync('1.txt', 'r');
console.log(fd);

var fs = require('fs');
fs.open('1.txt', 'r', function(err, fd){
	if (err){
		console.log('文件打开失败');
	} else {
		//读取文件
		/*
		 * fs.read(fd, buffer, offset, length, position, callback)
		 *   fd: 通过open方法成功打开一个文件返回的编号
		 *   buffer: buffer对象
		 *   offset: 偏移量，新的内容添加到buffer中的起始位置
		 *   length: 长度，添加到buffer中的内容的长度
		 *   position:位置，读取的文件中的起始位置
		 *   callback: 回调
		 *      err
		 *      buffer的长度
		 *      buffer
		 */
		var bf1 = new Buffer('123456789');
		console.log(bf1);
		fs.read(fd, bf1, 0, 4, null, function(err, len, newBf){
			console.log(bf1);
			console.log(len);
			console.log(newBf);
		});
	}
});

var fs = require('fs');

fs.open('1.txt', 'r+', function(err, fd){
	/*
	 * 当我们要对打开的文件进行写操作的时候，打开方式就不能是只读r，而是读写r+
	 * fs.write(fd, buffer, offset, length[, position], callback)
	 * fd: 打开的文件
	 * buffer: 要写入的数据
	 * offset: buffer对象中要写入的数据的起始位置
	 * length: 要写入的buffer数据的长度
	 * position: fd中的起始位置
	 * callback: 回调
	 */
	
	if (err){
		console.log('打开文件失败');
	} else {

		/*var bf = new Buffer('123');
		fs.write(fd, bf, 0, 3, 5, function(){
			console.log(arguments); //第一个参数是错误信息；第二个参数是写入的长度；第三个参数是写入的buffer信息
		});*/

		fs.write(fd, '1234', 5, 'utf-8');

		fs.close(fd, function(){

		});
	}
})

var fs = require('fs');
var filename = '2.txt';

/*fs.writeFile(filename, 'hello', function(err){
	console.log(arguments);
})*/

/*fs.appendFile(filename, '-leo', function(err){
	console.log(arguments);
})*/

/* 异步方式实现，代码很难看
fs.exists(filename, function(isExists){
	//console.log(isExists);

	if(!isExists){
		fs.writeFile(filename, 'miaov', function(err){
			if(err){
				console.log('出错了');
			} else {
				console.log('创建新文件成功');
			} else {
				fs.appendFile(filename, '-leo', function(err){
					if(err){
						console.log('新内容追加失败');
					} else {
						console.log('新内容追加成功');
					}
				})
			}
		})
	}
});
*/

//以下是同步模式的
if (!fs.existsSync(filename)){
	fs.writeFileSync(filename, 'miaov');
	console.log('新文件创建成功');
} else {
	fs.appendFileSync(filename, '-leo');
	console.log('新文件追加成功');
}

var fs = require('fs');

fs.readFile('2.txt', function(err, data){
	//console.log(arguments);

	if(err){
		console.log('文件读取失败');
	} else {
		console.log(data.toString());
	}
})

fs.unlink('2.txt', function(err){
	if(err){
		console.log('删除失败');
	} else {
		console.log('删除成功');
	}
})

var fs = require('fs');
fs.rename('2.txt', '2.new.txt', function(err){
	console.log(arguments);
})

fs.stat('2.new.txt', function(err, stat){
	console.log(arguments)
})

var fs = require('fs');

var filename = '2.new.txt';
fs.watch(filename, function(ev, fn){
	console.log(ev);
	if(fn){
		console.log(fn + '发生了改变');
	} else {
		console.log('...');
	}
})

var fs = require('fs');

fs.mkdir('./1', function(err){
	console.log(arguments);
});

fs.rmdir('./1', function(err){
	console.log(arguments);
})

fs.readdir('./', function(err, fileList){
	//console.log(fileList);
	fileList.forEach(function(f){
		fs.stat(f, function(err, info){
			//console.log(arguments);

			switch(info.mode){
				case 16822:
					console.log('[文件夹]' + f);
					break;
				case 33206:
					console.log('[文件]' + f);
					break;
				default:
					console.log('[其他类型]' + f);
					break;
			}
		});
	})
})

var projectData = {
	'name': 'miaov',
	'fileData': [
		{
			'name': 'css',
			'type': 'dir'
		},
		{
			'name': 'js',
			'type': 'dir'
		},
		{
			'name': 'images',
			'type': 'dir'
		},
		{
			'name': 'index.html',
			'type': 'file',
			'content': '<html>\n\t<head>\n\t\t<title>title</title>\n\t</head>\n\t<body>\n\t\t<h1>Hello</h1>\n\t</body>\n</html>'
		},
	]	
};

var fs = require('fs');

if(projectData.name){
	fs.mkdirSync(projectData.name);

	var fileData = projectData.fileData;
	
	if(fileData && fileData.forEach){
		fileData.forEach(function(f){
			f.path = projectData.name + '/' + f.name;
			f.content = f.content || '';
				case 'dir':
					fs.mkdirSync(f.path);
					break;
				case 'file':
					fs.writeFileSync(f.path, f.content);
					break;
				default:
					break;
			}
		})
	}
}

var fs = require('fs');
var filedir = './miaov/source';

fs.watch(filedir, function(ev, file){
	//console.log(ev + '/' + file); //这里不需要判断file是否有内容，因为有可能是删除导致事件的发生

	//只要source文件夹中有一个文件发生了变化，我们就需要对这个文件夹下的所有文件进行读取，然后合并
	fs.readdir(filedir, function(err, dataList){
		var arr = [];
		dataList.forEach(function(f){
			if (f) {
				var info = fs.statSync(filedir + '/' + f);
				//console.log(info);

				if(info.mode == 33206){
					arr.push(filedir + '/' + f);
				}
			}
		})

		//console.log('arr');

		//读取数组中的文件内容，并合并

		var content = '';
		arr.forEach(function(f){
			var c = fs.readFileSync(f);
			//console.log(c);
			content += c.toString() + '\n';
		});

		console.log(content);
		fs.writeFile('./miaov/js/index.js', content);
	})
})

//搭建一个http服务器，用于处理用户发送的http请求

//加载一个http模块
var http = require('http');

//通过http模块下的createServer创建并返回一个web服务器对象
var server = http.createServer();

/*
server.on('error', function(err){
	console.log(err);
})
*/

server.on('listening', function(){
	console.log('listening...');
})

server.listen(52346, 'localhost');

//console.log(server.address());

var http = require('http');
var server = http.createServer();

server.on('listening', function(){
	console.log('listening...');
})

server.on('request', function(){
	//console.log('有客户端请求了');
})

server.listen(52346, 'localhost');

var http = require('http');
var server = http.createServer();

server.on('listening', function(){
	console.log('listening...');
})

server.on('request', function(req, res){
	//console.log(req);

	//res.write('hello');

	res.setHeader('miaov', 'leo');

	res.writeHead(200, 'Nice Day', {
		//'content-type' : 'text/plain'
		'content-type' : 'text/html;charset=utf-8'
	});

	/*
	res.write('<h1>hello</h1>');
	res.end();
	*/

	res.end('<h1>hello</h1>');
})

server.listen(52346, 'localhost');

var http = require('http');
var url = require('url');

var server = http.createServer();

server.on('request', function(req, res){
	//req.url：访问路径
	//?后面的部分 query string
	//console.log(req.url);

	var urlStr = url.parse(req.url);
	//console.log(urlStr);
	switch(urlStr.path){
		case '/':
			//首页
			res.writeHead(200, {
				'content-type': 'text/html;charset=utf-8'
			})
			res.end('<h1>这是首页</h1>')
			break;
		case '/user':
			//用户
			res.writeHead(200, {
				'content-type': 'text/html;charset=utf-8'
			})
			res.end('<h1>个人</h1>')
			break;
		default:
			//处理其他情况
			res.writeHead(404 {
				'content-type': 'text/html;charset=utf-8'
			})
			res.end('<h1>页面被吃掉了</h1>')
			break;
	}
});

server.listen(8080, 'localhost')

var http = require('http');
var url = require('url');
var fs = require('fs');

var server = http.createServer();

var HtmlDir = __dirname + '/html/';

server.on('request', function(req, res){
	var urlStr = url.parse(req.url);

	switch(urlStr.path){
		case '/':
			//首页
			sendData(HtmlDir + 'index.html', req, res);
			break;
		case '/user':
			//用户
			sendData(HtmlDir + 'user.html', req, res);
			break;
		default:
			//处理其他情况
			sendData(HtmlDir + 'err.html', req, res);
			break;
	}
});

function sendData(file, req, res){
	fs.readFile(file, function(err, data){
		if(err){
			res.writeHead(404, {
				'content-type' : 'text/html;charset=utf-8'
			});
			res.end('<h1>页面找不到</h1>')
		} else {
			res.writeHead(200, {
				'content-type' : 'text/html;charset=utf-8'
			});
			res.end(data)
		}
	})
}

server.listen(8080, 'localhost');

var http = require('http');
var url = require('url');
var fs = require('fs');
var querystring = require('querystring');

var server = http.createServer();

var HtmlDir = __dirname + '/html/';

server.on('request', function(req, res){
	var urlStr = url.parse(req.url);

	switch(urlStr.path){
		case '/':
			//首页
			sendData(HtmlDir + 'index.html', req, res);
			break;
		case '/user':
			//用户

			//get方式可以直接得到
			//console.log(querystring.parse(urlStr.query))
			
			//post方式要用req的data和end事件
			if(req.method.toUpperCase() == 'POST'){
				var str = '';
				req.on('data', function(chunk){
					str += chunk;
				})

				req.on('end', function(){
					//console.log(str);
					console.log(querystring.parse(str));
				})
			}

			sendData(HtmlDir + 'user.html', req, res);
			break;
		default:
			//处理其他情况
			sendData(HtmlDir + 'err.html', req, res);
			break;
	}
});

function sendData(file, req, res){
	fs.readFile(file, function(err, data){
		if(err){
			res.writeHead(404, {
				'content-type' : 'text/html;charset=utf-8'
			});
			res.end('<h1>页面找不到</h1>')
		} else {
			res.writeHead(200, {
				'content-type' : 'text/html;charset=utf-8'
			});
			res.end(data)
		}
	})
}

server.listen(8080, 'localhost');