//浏览器中的JavaScript是没有文件操作的能力的
//但是Node中的JavaScript具有文件操作的能力
//fs模块：文件系统

//读取文件
//参数1：要读取的文件路径
//参数2：回调函数
//(1)error  (2)data
/*
	成功
	data   数据
	error  null

	失败
	data    undefined
	error  错误对象
*/
var fs = require('fs')
fs.readFile("./data/helloword.txt",function(error,data){
	/*
		.文件存储的数据是二进制，这里显示的是二进制转成的16进制
		.需要用toString()方法显示为字符串
	*/
	if (error) {
		console.log("读取失败！");
	}else{
		console.log(data.toString());
	}
});

//写入文件
/*
参数1：写入的文件路径
参数2：写入文件的内容
参数3：回调函数

	成功
	error:null
	失败
	error:错误对象
*/
fs.writeFile('./data/你好.md','大家好，我是Node.js',function(error){
	if (error) {
		console.log('文件写入失败');
	}else{
		console.log('文件写入成功');
	}
	
});

//1.创建 http 核心对象
var http = require('http');

//2.创建一个Web服务
var server = http.createServer();

//3.接受请求，处理请求，发送响应
//request 请求事件处理函数，需要接收两个参数：
//  Request  请求对象
//		请求对象可以用来获取客户端的一些请求信息，例如请求路径
//	Response  响应对象
//		响应对象可以用来给客户端发送响应信息
server.on('request',function(request,response){
	console.log('收到客户端的请求了，请求路径是'+request.url);

	//response 对象有一个方法：write 可以用来给客户端发送响应数据
	//write 可以使用多次，但是最后一定要使用end 来结束响应，否则客户端会一直等待
	response.write('hello');
	response.write(' nodejs');
	response.end();
});

//4.绑定端口号，启动服务
server.listen(3000,function(){
	console.log("服务已启动");
});


//---------------------------------简写---------------------------------------------
var http = require('http')
http
    .createServer(function(req,res){
    	console.log('请求路径是：'+req.url)
    	response.end('hello nodejs')
	})
    .listen(3000,function(){
    	console.log('服务已启动...')
	})

//url 模块
var url = require('url')

//使用url.parse 方法将路径解析为一个方便操作的对象，第二个参数为 true 表示直接将查询字符串转为一个对象（通过query属性来访问）
var obj = url.parse('/pinglun?name=水电费&message=发送到第三方')

console.log(obj)
console.log(obj.query)

// require 是一个方法
// 它的作用就是用来加载模块的
// 在 Node 中，模块有三种：
//    具名的核心模块，例如 fs、http
//    用户自己编写的文件模块
//      相对路径必须加 ./
//      可以省略后缀名
//      相对路径中的 ./ 不能省略，否则报错
//    在 Node 中，没有全局作用域，只有模块作用域
//      外部访问不到内部
//      内部也访问不到外部
//      默认都是封闭的
//    既然是模块作用域，那如何让模块与模块之间进行通信
//    有时候，我们加载文件模块的目的不是为了简简单单的执行里面的代码，更重要是为了使用里面的某个成员


console.log('a start');
require('./b.js');//相对路径要加 ./，可以省略后缀名
console.log('a end');

//Node中没有全局作用域，只有模块作用域，以下变量不能被外部分访问！，如果使模块间进行通信，请看加载和导出。
var foo = "afoo";

//    在每个文件模块中都提供了一个对象：exports
//    exports 默认是一个空对象
//    你要做的就是把所有需要被外部访问的成员挂载到这个 exports 对象中
var foo = 'bbb'

// console.log(exports)

exports.foo = 'hello'

exports.add = function (x, y) {
  return x + y
}

exports.readFile = function (path, callback) {
  console.log('文件路径：', path)
}

var age = 18

exports.age = age

function add(x, y) {
  return x - y
}

// require 方法有两个作用：
//    1. 加载文件模块并执行里面的代码
//    2. 拿到被加载文件模块导出的接口对象
var bExports = require('./b')
var fs = require('fs')

console.log(bExports.foo)

console.log(bExports.add(10, 30))

console.log(bExports.age)

bExports.readFile('./a.js')

fs.readFile('./a.js', function (err, data) {
  if (err) {
    console.log('读取文件失败')
  } else {
    console.log(data.toString())
  }
})

var http = require('http');

var server = http.createServer();

server.on('request',function(req,res) {
	//在服务默认发送的数据，其实是 utf-8 编码的内容
	//但是浏览器不知道你是 utf-8 编码内容
	//浏览器在不知道服务器响应内容的编码情况下会按照当前操作系统的默认编码去解析
	//中文操作系统默认是 gbk
	//解决方法就是正确的告诉浏览器我给你发送的内容是什么编码的
/*	res.setHeader('Content-Type','text/plain;charset=utf-8');
	res.end('hello 世界');*/

	var url = req.url;
	if (url === '/plain') {
        //如果你响应的数据是html页面，页面的编码方式也会生效，在这里可以省略setHeader
		// text/plain 就是普通文本
		res.setHeader('Content-Type','text/plain;charset=utf-8');
		res.end('hello 世界');
	}else if(url === '/html'){
		// text/html  html文本
		res.setHeader('Content-Type','text/html;charset=utf-8');
		res.end('<p><a href="">hello 世界</a></p>');
	}
});

server.listen(3000,function() {
	console.log('服务已启动...');
});

nmp install art-template

//	在需要使用的文件模块中加载 art-template
//	只需要使用 require 方法加载就可以了
//	参数中的 art-template 就是你下载的包的名字
//  也就是说你 isntall 的名字是什么，则你 require 中的就是什么

var template = require('art-template')

var fs = require('fs')

fs.readFile('./tpl.html',function(err,data) {
	if (err) {
		return console.log('读取文件失败了');
	}


	//默认读取到的 data 是二进制数据
	//二模板引擎 render 方法需要接收的是字符串
	//所以我们在这里需要把 data 二进制数据转为 字符串 才可以给模板引擎使用
	var ret = template.render(data.toString(),{
		name: 'Jack',
		age: 18,
		province: '北京市',
		hobbies:[
			'写代码',
			'唱歌',
			'打游戏'

		]
	})
});

//把当前模块所有的依赖项都什么在文件模块最上面 
var http = require('http')
 var fs = require('fs')
 var tempalte = require('art-template')
 var url = require('url')

 var comments = [
 	{
 		name:'张三1',
 		message:'今天天气不错',
 		dateTime:'2015-01-30'
 	},
 	{
 		name:'张三2',
 		message:'今天天气不错',
 		dateTime:'2015-01-30'
 	},
	.......
 ]

//初始化服务简写
 http
 	.createServer(function(req,res) {
     	//这里使用url对象是因为发表留言提交数据时的请求路径是动态的，只能通过它来获取
 		var parseObj = url.parse(req.url,true)
 		var pathName = parseObj.pathname
 		
        //pathname可以获取 ? 前不带字符串参数的路径
 		if(pathName === '/'){
 			fs.readFile('views/index.html',function(err,data){
 				if (err) {
 					return res.end('404 Not Found!')
 				}
 				//模板引擎-页面渲染 render(要渲染的页面（字符串），要渲染的数据)
 				var htmlStr = tempalte.render(data.toString(),{
 					comments:comments
 				})
 				res.end(htmlStr)
 			})
 		}else if (pathName.indexOf('/public/') === 0) {
 			//如果请求路径是以 /public/ 开头的，则认为要获取 public 中的某个资源
 			//所以我们就直接可以把请求路径当作文件路径来直接进行读取
 			console.log(url)
 			fs.readFile('.'+pathName,function(err,data) {
 				res.end(data)
 			})
 		}else if (pathName === '/post') {
 			fs.readFile('views/post.html',function(err,data) {
 				res.end(data)
 			})
 		}else if (pathName === '/pinglun') {

 			var comment = parseObj.query
 			comment.dateTime = '2017-11-2 17:11:22'
 			//comments.push(comment)
 			comments.unshift(comment)//数组头部追加
 			res.statusCode = 302
 			res.setHeader('Location','/')
 			res.end() //记住要结束响应
 		}else{
 			fs.readFile('views/404.html',function(err,data) {
 				res.end(data)
 			})
 		}
 	})
 	.listen(3000,function() {
 		console.log('running...')
 	})

var 变量名 = require('模块')

exports.a = '123'
exports.b = 'hello'
exports.c = function() {
	console.log('ccc')
}
exports.d = {
	foo:'bar'
}

module.exports = 'bar'

//这里导出了多个，后者会覆盖前者
module.exports = function(x,y) {
	return x+y
}

module.exports = {
	str:'1',
	foo:'bar'
}

//在node中的自定义模块默认有以下
var module = {
	exports:{

	}
}

var exports = module.exports

return module.exports

//路径形式的模块：
// ./  当前目录，不可省略
// ../  上一级目录，不可省略
//  /xxx 这里的 / 指的是盘符根路径，几乎不用
//  d:/a/foo.js  绝对路径，几乎不用
// .js 后缀名可省略
require('标识模块')

//核心模块的本质也是文件
//核心模块文件已经被编译到	了二进制文件了，我们只需要按照名字来加载就可以了
require('fs')
require('http')

//第三方模块
//凡是第三方模块都必须通过 npm 来下载
//使用的时候就可以通过 require('包名') 的方式来进行加载才可以使用
//不可能有任何一个第三方包和核心模块的名字是一样的
//既不是核心模块，也不是路径形式的模块
//  先找到当前文件所属目录中的 node_modules 目录
//  node_modules/art-emplatet
//  node_modules/art-template/package.json 文件
//  node_modules/art-template/package.json 文件中的 main 属性
//  main 属性中就记录了当前 art-template 的入口模块
//  然后加载使用这个第三方包
//  实际上最终加载的还是文件

//	如果 package.json 文件不存在或者 main 指定入口模块也没有
//  则 node 会自动找到目录下的 index.js
//	也就是说 index.js 会作为一个默认备选项
//  如果以上任何条件都成立，则会进入上一级目录中的 node_modules 目录查找
//  如果上一级还没有，则会继续往上上一层查找
// ...
//  如果直到当前磁盘根目录还找不到，最后报错:
//		can not find module xxx 
//  注意：我们一个项目有且只有一个 node_modules 放在项目根目录中，这样的话项目中所有的子目录中的代码都可以加载到第三方包,
//  不会出现多个 node_modules
var template = require('art-template')

//可以通过命令行查询版本
npm --version

//通过命令升级版本
npm install --global npm

#在任意目录执行都可以
# --global 表示安装到全局，而非当前目录
# --global 不能省略，否则不管用
npm install --global cnpm

#这里还是走国外的 npm 服务器，速度比较慢
npm install jquery
#使用 cnpm 就会通过淘宝的服务器来下载 jquery
cnpm install jquery

npm install jquery --registry=https://registry.npm.taobao.org

npm config set registry https://registry.npm.taobao.org

#查看 npm 配置信息
npm config list

PS C:\Users\jxGZ1\Desktop\nodeTest> npm init	//初始化包
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help json` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg>` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
package name: (nodetest)			//包名
version: (1.0.0) 1.0.1				//版本
description: 这是一个测试项目		  //项目说明
entry point: (index.js) main.js		 //项目入口
test command:
git repository:						//githup仓库地址
keywords:						    //项目关键字（如果你要发布第三方模块到n）
author: ruanhuasi					//作者
license: (ISC)						//开源许可证
About to write to C:\Users\jxGZ1\Desktop\nodeTest\package.json:

{
  "name": "nodetest",
  "version": "1.0.1",
  "description": "这是一个测试项目",
  "main": "main.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "ruanhuasi",
  "license": "ISC"
}


Is this OK? (yes) yes

{
  "name": "nodetest",
  "version": "1.0.1",
  "description": "这是一个测试项目",
  "main": "main.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "ruanhuasi",
  "license": "ISC",
  "dependencies": {				// dependencies 就是包依赖的信息
    "art-template": "^4.13.2",
    "bootstrap": "^4.1.3",
    "jquery": "^3.3.1"
  }
}

var fs = require('fs')
var path = require('path')

// 模块中的路径标识和文件操作张的相对路径的表示不一样
// 模块中的路径标识就是相对于当前文件模块，不受执行 node 命令所处路径影响
require('./b')

// 在文件操作时，建议把所有的路径都变成动态的绝对路径，使用两个东西：
// 1. __dirname 或者 __filename 来动态获得绝对路径
// 2. path 模块的 join() 方法用来辅助拼接路径，避免拼接出错
fs.readFile(path.join(__dirname,'./a.txt'),'utf8',function(err,data){
	if (err) {
		throw err
	}
	console.log(data)
})

npm install --save express

var express = require('express')

// 1.创建 app
var app = express()

app.get('/',function(req,res) {
	// res.write('hello')
	// res.write('world')
	// res.end()
	
	//res.end('hello world')

	res.send('hello world')
})

app.listen(3000,function() {
	console.log('express app is running...')
})

//当你以 GET 方法请求 /  的时候，执行对应的处理函数
app.get('/login',function(req,res) {
	res.send('login page1')
})

//当你以 POST 方法请求 / 的时候，执行对应的处理函数
app.post('/',function(req,res) {
	res.send('Got a POST request')
})

//1.当请求路径以 /public/ 开头的时候，去 ./public/ 目录中找对应的资源
//这种方式更容易辨识，推荐这种方式
app.use('/public/',express.static('./public/'))

//2.指定路径名称（相当于给 /public/ 起别名）
app.use('/abc/d/',express.static('./public/'))

//3.当省略第一个参数的时候，则可以通过 省略 /public 的方式访问
//这种方式的好处就是可以省略 /publiuc/
app.use(express.static('./public/'))

app.use('/static',express.static(path.join(_dirname,'public')))

app.engine('art',require('express-art-template'))
//也可以指定视图为 .hmtl 结尾
app.engine('html',require('express-art-template'))

app.get('/',function(req,res){
    //express 默认回去项目的 views 目录中 index.html
    res.render('index.html',{
        title:'hello world'
    })
})

//注意：第一个参数 views 千万不要写错
app.set('views',目录路径)

app.use(function (req, res, next) {
  console.log('Time:', Date.now())
  next()
})

app.use('/a',function (req, res, next) {
  console.log('Time:', Date.now())
  next()
})

app.get('/',function (req, res) {
  res.send('Hello World!')
})

app.post('/',function (req, res) {
  res.send('Got a POST request')
})

app.put('/user',function (req, res) {
  res.send('Got a PUT request at /user')
})

app.delete('/user',function (req, res) {
  res.send('Got a DELETE request at /user')
})

app.use(function (err,req, res, next) {
   console.error(err.stack)
   res.status(500).send('Something broke')
 })

req.query

var express = require('express')
//0.引包
var bodyParser = require('body-parser')

var app = express()

// 配置 body-parser
// 只要加入这个配置，则在 req 请求对象上会多出来一个属性：body
// 也就是说你就可以直接通过 req.body 来获取表单 POST 请求数据了
// parse application/x-www-form-urlencoded
app.use(bodyParser.urlencoded({ extended: false }))

// parse application/json
app.use(bodyParser.json())

app.use(function (req, res) {
  res.setHeader('Content-Type', 'text/plain')
  res.write('you posted:\n')
    // 可以通过 req.body 来获取表单 POST 请求体数据
  res.end(JSON.stringify(req.body, null, 2))
})

// 该插件会为 req 请求对象添加一个成员：req.session 默认是一个对象
// 这是最简单的配置方式，暂且先不用关心里面参数的含义
app.use(session({
// secret是配置加密字符串，它会在原有加密基础之上和这个字符串拼接起来去加密
// 目的是为了增加安全性，防止客户端恶意伪造
  secret: 'itcast', 
  resave: false,
  saveUninitialized: true // 无论你是否使用 Session,我都默认直接给你分配一把钥匙
}))
 

// 添加 Session 数据
req.session.foo = 'bar'

// 获取 Session 数据
req.session.foo

/**
* router.js 路由模块
* 职责：
* 	处理路由
*	根据不同的请求方法+请求路径设置具体的请求处理函数
* 模块职责要单一，不要乱写
* 我们划分模块的目的就是为了增强项目代码的可维护性
* 提升开发效率
*/

var fs = require('fs')

// Express 提供了一种比封装函数更好的方式
// 专门用来包装路由的
var express = require('express')

// 1.创建一个路由容器
var router = express.Router()

// 2.把路由都挂载到 router 路由容器中
router.get('/students/new',function(req,res){
	res.render('new.html')
})

router.get('/students/edit',function(req,res){
	
})

router.post('/students/edit',function(req,res){
	
})

router.get('/students/delete',function(req,res){
	
})


// 3.把 router 导出
module.exports = router

/**
* app.js 入口模块
* 职责：
* 	创建服务
*	做一些服务相关配置
*		模板引擎
*		body-parser 解析表单 post 请求体
*		提供静态资源服务
*	挂载路由
*	监听端口启动服务
*/
var express = require('express')

#导入路由
var router = require('./router')

var bodyParser = require('body-parser')

var app = express()

// 配置模板引擎和 body-parser 一定要在 app.use(router) 挂载路由之前
app.engine('html',require('express-art-template'))

app.use(bodyParser.urlencoded({ extended: false }))
app.use(bodyParser.json())

#把路由容器挂载到 app 服务中
app.use(router)

app.listen(3000,function(){
	console.log('running...')
})

/*
	student.js
	数据操作文件模块
	职责：操作文件中的数据，只处理数据，不关心业务
*/

/*
	获取所有学生列表
	return []
*/
exports.find = function() {

}

/*
	添加保存学生
*/
exports.save = function() {

}

/*
	更新学生
*/
exports.update = function() {

}

/*
	删除学生
*/exports.delete = function() {

}

{
    qq:{
        users:[
            {name:'张三',age:15},
            {name:'李四',age:15},
            {name:'王五',age:15},
            {name:'张三123',age:15},
            {name:'张三456',age:15}
            ...
        ],
        products:[
                
        ]
        ...
    },
    taobao:{
            
    },
    baidu:{
            
    }
}

npm i mongoose

var mongoose = require( 'mongoose' );

// 连接 MongoDB 数据库
mongoose.connect( 'mongodb://localhost/test');

mongoose.Promise = global.Promise;

// 创建一个模型
// 就是在设计数据库
// MongoDB 是动态的，非常灵活，只需要在代码中设计你的数据库就可以了
// mongoose 这个包就可以让你的设计编写过程变得非常的简单	
var Cat = mongoose.model( 'Cat', { name: String } );

// 实例化一个 Cat
var kitty = new Cat( { name: 'Zildjian' } );

// 持久化保存 kitty 实例
kitty.save()(function(err) {
	if(err){
		console.log(err)
	}else{
		console.log('meow')
	}
});

var mongoose = require('mongoose')

var Schema = mongoose.Schema //结构对象

// 1.连接数据库
// 指定连接的数据库不需要存在，当你插入第一条数据之后就会自动被创建出来，这里的 itcast 就是即将要创建的数据库名
mongoose.connect('mongodb://localhost/itcast')

// 2.设计文档结构（表结构）
// 字段名称就是表结构中的属性名称
// 值
// 约束的目的是为了保证数据的完整性，不要有脏数据
  var userSchema = new Schema9({
  	username:{
  		type:String,  // 类型
  		required:true // 非空
  	},
  	password:{
  		type:String,
  		required:true
  	},
  	email:{
  		type:String
  	}
  })

  // 3.将文档结构发布为模型
  // 	mongoose.model 方法就是用来将一个架构发布为 model
  // 	第一个参数：传入一个大写名词单数字符串用来表示你的数据库名词
  // 				mongoose 会自动将大写名词的字符串生成 小写复数 的集合名称
  // 				例如这里的 User 最终会变为 users 集合名称
  // 	第二个参数：架构 Schema
  // 	
  // 	返回值：模型构造函数（模型对象）
   var User = mongoose.model('User', userSchema);


 // 4.当我们有了模型构造函数之后，就可以使用这个构造函数对 User 中的数据为所欲为了

var admin = new User({
  username:'张三',
  password:'123456',
  email:'admin@admin.com'
})

 admin.save(function(err,ret) {
 	if(err){
 		console.log('保存失败')
 	}else{
 		console.log('保存成功')
 		console.log(ret)
 	}
 })

#查询所有
User.find(function(err,ret){
    if (err) {
      console.log('查询失败')
    }else{
      console.log(ret)
    }
 })

#条件查询
 User.find({
  username:'张三',
  password:'123456'
 },function(err,ret){
    if (err) {
      console.log('查询失败')
    }else{
      console.log(ret)
    }
 })

#查询单个
User.findOne(function(err,ret){
    if (err) {
      console.log('查询失败')
    }else{
      console.log(ret)
    }
 })

#根据条件删除所有
User.remove({
  username:'张三'
},function(err,ret){
  if (err) {
    console.log('删除失败')
  }else{
    console.log('删除成功')
    console.log(ret)
  }
})

#根据条件删除一个
Model.findOneAndRemove(conditions,[options],[callback])

#根据 id 删除一个
Model.findByIdAndRemove(id,[options],[callback])

#根据条件更新所有
Model.update(conditions,doc,[options],[callback])

#根据条件更新一个
Model.findOneAndUpdate([conditions],[update],[options],[callback])

#根据 id 更新一个
User.findByIdAndUpdate('5bfd259219c0b03acc3e7e81',{
  password:'123'
},function(err,ret){
  if (err) {
    console.log('更新失败')
  }else{
    console.log('更新成功')
  }
})

function(x,y){
    setTimeout(function(){
        var ret = x +y
        return ret
    },1000)
    //到这里执行就结束了，不会等到前面的定时器，所以就直接返回了默认值 undefined
    
    console.log(add(10,20)) // => undefined
    
    
    //注意：凡是需要得到一个函数内部异步操作的结果
    // setTimeout
    // readFile
    // writeFile
    // ajax
    // 这种情况必须通过：回调函数
    
    functin add(x,y,callback){
        // callback 就是回调函数
        // var x = 10
        // var y = 20
        // var callback = function(a){ console.log(ret) }
        console.log(1)
        setTileout(function(){
            var ret =x + y
            callback(ret)
        },1000)
    }
    
    add(10,20,function(a){
        //在这里拿到结果可以做任何操作
        console.log(a)
    })
    
}