node.js从入门到放弃（一）

以下内容全是我个人理解写出，如有不对，请立刻练习本人进行更改。以免被刚入门的被我带入坑里。

—node是什么？我想大家应该都知道。

node是前端未来干掉后端的一种语言，是用JavaScript来编写后端代码的一种语言。前端走后端的路让后端无路可走。是前端人员走向全栈开发的一条路。

—学习node要掌握什么呢？学习它就需要掌握一下几个方面，这是我现在学习的时候需要掌握的东西，算是很基本的东西了。

一、node的安装

二、数据库的安装和使用（sql命令）

三、node最底层基本写法

四、koa框架

五、Sequelize功能模块使用

六、读写文件

node的安装在这里就不讲了，网上一搜就都能搜到的，不想搜也可以点击这个连接，去看下node安装这些都有详细的介绍。

数据库的安装在网上也能够搜索到，安装数据库可以看下这个博客，这里写的挺详细的，从安装数据库到navicat MySQL的安装都有  查看请点击这里↓↓↓↓↓↓↓

sql的命令离不开增删改查

mydb：数据库名

user：表名

text：对应的属性名

2：要插入的数据

id：主键

age：对应的属性

增： INSERT INTO `mydb`.`user` (`text`) VALUES (‘2‘);

删：DELETE FROM user WHERE id=1

改：UPDATE `mydb`.`user` SET `age`=‘22‘ WHERE `id`=‘1‘;

查：select * from user

以上就是数据操作的主要四个，其他命令可以百度一下，一抓一大把。

接下来进入最主要的地方了，开是接触放弃的地方了，底层的基本用法

+开始需要把数据库放进去才能够使用

$ cnpm install mysql

　接下来引入你本地的数据库

// 连接数据库
var mysql      = require(‘mysql‘);
var connection = mysql.createConnection({
host     : ‘localhost‘,
user     : ‘root‘,
password : ‘123456‘,
database : ‘node‘
});

　接下来开始捣鼓你的数据库（我的数据库放了一下的数据名）

接下来对下面的数据进行操作（用上面已经连接上的数据库）

node底层写法：

var http = require(‘http‘);
// 连接数据库
var mysql      = require(‘mysql‘);
var connection = mysql.createConnection({
host     : ‘localhost‘,
user     : ‘root‘,
password : ‘123456‘,
database : ‘node‘
});
// 请求下数据库
connection.connect();
var http = require("http");
var url = require("url");
// 调用方法
function start() {
  function onRequest(request, response) {}
  http.createServer(onRequest).listen(8888);　端口号是8888去进行请求
}
start();

　　新增数据方法

// 新增数据
const hello = function (response, data) {
  connection.query(`INSERT INTO log  (content, summary, user, day) VALUES ("${data.content}", "${data.summary}", "${data.user}","${data.day}");`, function (error, results, fields) {
    if (error) throw error;
      // 请求成功，返回格式
      response.writeHead(200, {"Content-Type": "application/json"});
      // 返回给页面的数据
      response.write(JSON.stringify(results.insertId));
      // 请求结束
      response.end();
  });
}

　　获取列表

//  获取列表
const hello2 = function (response, data) {
  connection.query(`select * from log`, function (error, results, fields) {
    if (error) throw error;
      response.writeHead(200, {"Content-Type": "application/json"});
      response.write(JSON.stringify(results));
      response.end();
  });
}

　　删除事件

// 删除id=4
const hello4 = function (response,data){
  console.log(data)
  connection.query(`DELETE FROM log WHERE id=${data.id}`,function (error,results,fields) {
    if (error) throw error;

    response.write("ok");
    response.end();
  })
}

　　分页写法

// 分页写法
const hello3 = function (response, page, size) {
  console.log(‘page, size‘, page, size)
  connection.query(`select * from log  limit ${size} offset ${(page-1)*size} `, function (error, results, fields) {
    if (error) throw error;
      response.writeHead(200, {"Content-Type": "application/json"});
      response.write(JSON.stringify(results));
      response.end();
  });
}

　　调用的话直接调用方法就可以（这里还需要注意是get请求还是post请求）

// 调用方法
function start() {
  function onRequest(request, response) {
    // /hello
    var pathname = url.parse(request.url).pathname.split(‘/‘);
    // /hello3/1/10
    // 接收数据
    if (request.method === ‘POST‘) {
      request.on(‘data‘, function(data) {
        // 把数据转换成json格式
        let data1 = JSON.parse(data.toString())
        console.log(‘data: ‘, data1.toString(), data1)
        // 接收到的接口调用什么方法
        switch(pathname[1]) {
          case ‘hello‘: { hello(response, data1) } break;
          case ‘hello2‘: { hello2(response, data1) } break;
          case ‘hello3‘: {
            // 用拼接的方式（get）获取数据方法
            // let page = pathname[2]
            // let size = pathname[3]
            // console.log(pathname)
            // 用接收体来调用数据（post）
            hello3(response, data1.page, data1.size)
          } break;
          case ‘hello4‘: { hello4(response, data1) } break;
          // 调用weitch方法
          default: response.end();
        }
      })
    }

　　完整的使用代码

var http = require(‘http‘);
// 连接数据库
var mysql      = require(‘mysql‘);
var connection = mysql.createConnection({
host     : ‘localhost‘,
user     : ‘root‘,
password : ‘123456‘,
database : ‘node‘
});
// 请求下数据库
connection.connect();
var http = require("http");
var url = require("url");
// 新增数据
const hello = function (response, data) {
  connection.query(`INSERT INTO log  (content, summary, user, day) VALUES ("${data.content}", "${data.summary}", "${data.user}","${data.day}");`, function (error, results, fields) {
    if (error) throw error;
      // 请求成功，返回格式
      response.writeHead(200, {"Content-Type": "application/json"});
      // 返回给页面的数据
      response.write(JSON.stringify(results.insertId));
      // 请求结束
      response.end();
  });
}
//  获取列表
const hello2 = function (response, data) {
  connection.query(`select * from log`, function (error, results, fields) {
    if (error) throw error;
      response.writeHead(200, {"Content-Type": "application/json"});
      response.write(JSON.stringify(results));
      response.end();
  });
}
// 删除id=4
const hello4 = function (response,data){
  console.log(data)
  connection.query(`DELETE FROM log WHERE id=${data.id}`,function (error,results,fields) {
    if (error) throw error;

    response.write("ok");
    response.end();
  })
}
// 分页写法
const hello3 = function (response, page, size) {
  console.log(‘page, size‘, page, size)
  connection.query(`select * from log  limit ${size} offset ${(page-1)*size} `, function (error, results, fields) {
    if (error) throw error;
      response.writeHead(200, {"Content-Type": "application/json"});
      response.write(JSON.stringify(results));
      response.end();
  });
}

// 调用方法
function start() {
  function onRequest(request, response) {
    // /hello
    var pathname = url.parse(request.url).pathname.split(‘/‘);
    // /hello3/1/10
    // 接收数据
    if (request.method === ‘POST‘) {
      request.on(‘data‘, function(data) {
        // 把数据转换成json格式
        let data1 = JSON.parse(data.toString())
        console.log(‘data: ‘, data1.toString(), data1)
        // 接收到的接口调用什么方法
        switch(pathname[1]) {
          case ‘hello‘: { hello(response, data1) } break;
          case ‘hello2‘: { hello2(response, data1) } break;
          case ‘hello3‘: {
            // 用拼接的方式（get）获取数据方法
            // let page = pathname[2]
            // let size = pathname[3]
            // console.log(pathname)
            // 用接收体来调用数据（post）
            hello3(response, data1.page, data1.size)
          } break;
          case ‘hello4‘: { hello4(response, data1) } break;
          // 调用weitch方法
          default: response.end();
        }
      })
    }

    // Get
    if (request.method === ‘GET‘) {
      response.end(‘aaaaa‘);
    }
  }

  http.createServer(onRequest).listen(8888);
}
start();

　　

开始化简模式。学习使用koa框架

安装koa

npm intall koa2
npm intall koa-router

　　在页面引入

const Koa = require(‘koa‘)
const bodyParser = require(‘koa-bodyparser‘)
const Router = require(‘koa-router‘)

　　来个简单例子

const Koa = require(‘koa‘);
//引入koa
  const app = new Koa();
  //方法放到app下
  app.use(async ctx => {
    ctx.body = ‘Hello World‘;
  });
  //执行方法
  app.listen(3000);
//app创建端口号

　　koa主要的就是request的请求方法，response响应，因为太多就不在这讲了，想了解的   戳这里↓↓↓↓↓

app.use(async ctx => {
    console.log(ctx.request.href)
//获取到地址，换个方法就可以获取前台传得数据
    ctx.response.body = "aaaaa"
//返回值
});

　　来上面的去看文档慢慢敲就行了，Sequelize功能模块使用来讲一下

var Sequelize = require(‘sequelize‘);
var mysql = new Sequelize(‘node‘, ‘root‘, ‘123456‘, {
    host: ‘localhost‘,
    dialect: ‘mysql‘,
    pool: {
        max: 5,
        min: 0,
        idle: 10000
    },
})

　　看数据库的导入方式就不一样了，接下来我们使用的可能多数都是这样的，样式了。

//数据表里面的内容
var Log = mysql.define(‘log‘, {
    id: {
        primaryKey: true,
        type: Sequelize.INTEGER,
    },
    content: Sequelize.STRING,
    summary: Sequelize.STRING,
    user: Sequelize.STRING,
    day: Sequelize.STRING,
  }, {
    freezeTableName: true, // Model 对应的表名将与model名相同
    timestamps: false
  });

　　使用方法查询数据

Log.findAll({
        where: {
            $and: [
                { id: {gt: 32} },
                 //大于多少
                { id: {lt: 35} }
                //小于等于多少
            ]
        },
        raw: true
    }).then(res => {
        console.log(res.length)
    //一共多少条
    for(var i=0 ;i<res.length;i++){
//遍历出来显示
        Log.create(
        {
            content: res[i].content,
            summary: res[i].summary,
            user: res[i].user,
            day: res[i].day
        }
    )
    }

})

　　整体使用

const main = async function() {
//查询所有
    let res = await Log.findAll({
        raw: true
    })
//写入
    let newDatas = res.map(item => ({
        a: item.content,
        b: item.summary,
        c: item.user,
        d: item.day,
    }))
//往新表里插入多条数据
    await Aaa.bulkCreate(newDatas)
//删除数据
    await Aaa.destroy({ where: {
        id: 2
    }})
//修改数据
    await Aaa.update({
        a: ‘item.content‘,
        b: ‘item.summary‘,
        c: ‘item.user‘,
        d: ‘item.day‘,
    }, {
        where: {
            id: 3
        }
    })
}

main()

　　接下来进行三军会师，用三种方法写成最简单的代码来调用数据

开始在app文件中

const Koa = require(‘koa‘)
const bodyParser = require(‘koa-bodyparser‘)
const router = require(‘./controllers‘)
//引入使用包
const app = new Koa()
app.use(bodyParser())
//调用koabadyparser方法
app.use(router.routes())
app.listen(3000)
//引入文件，创建端口

　　在controllers文件中写入方法并进行调用

const Router = require(‘koa-router‘)
const router = new Router()
const services = require(‘./services‘)

//查询所有数据
router.get(‘/‘, async (ctx, next) => {
    let res = await services.hello1()
    ctx.body = res
});
//返回值hello world
router.get(‘/hello‘, (ctx, next) => {
    ctx.body = "hello world"
});
//新增数据
router.post(‘/hello2‘, async (ctx, next) => {
    let obj = ctx.request.body
    let res = await services.hello2(obj)
    let eee = {
        content : res.content,
        summary : res.summary
    }
    ctx.body = {
        statusCode: 200,
        result:eee
    }
})
//删除数据
router.post(‘/hello3‘, async (ctx, next) => {
    let obj = ctx.request.body
    let res = await services.hello3(obj)

    ctx.body = {
        statusCode: 200,
    }
})
//查询数据
router.post(‘/hello4‘, async (ctx, next) => {
    let obj = ctx.request.body
    let res = await services.hello4(obj)
    ctx.body = res
})
//更改数据
router.post(‘/hello5‘, async (ctx, next) => {
    let obj = ctx.request.body
    let res = await services.hello5(obj)
    ctx.body = res
})
//调用
module.exports = router

　　在services.js文件中

const Log = require(‘./models‘)

const hello = async function (obj) {
    //放个查询方法
    let logs = await Log.Log.findAll({
        where: {
            $and: [
                {id: { $gt: obj.id }},
                {id: { $lte: obj.css }}
            ]
        }
    })

    return logs
}
//查询所有数据大于0的
const hello1 = async function () {
    let loge = await Log.Log.findAll({
        where: {
            id: { gt: 0},
        }
    })

    return loge
}
//新增数据
const hello2 = async function (obj) {
    let loge = await Log.rizhi.create({
            content:obj.content,
            summary:obj.summary,
            user:obj.user,
            day:"2015-10-7"
    })

    return loge
}
//删除数据
const hello3 = async function (obj) {
    let loge = await Log.rizhi.destroy({
           where:{
                id : obj.id
            }
     })

    return loge
}
查询数据
const hello4 = async function (obj) {
    let ass = {
        content : obj.content,
        summary : obj.summary,
        user : obj.user,
    }
    if(!obj.content){
       delete ass.content
    }
    if(!obj.summary){
        delete ass.summary
    }
    if(!obj.user){
        delete ass.user
    }
    let loge = await Log.rizhi.findAll({ 

           where:ass
     })

    return loge
}
//更改数据
const hello5 = async function (obj) {
    let ass = {
        content : obj.content,
        summary : obj.summary,
        user : obj.user,
    }

    let loge = await Log.rizhi.update(ass,{ 

           where:{
                id : obj.id
           }
     })
     let cha = await Log.rizhi.findAll({
        where: {
            id: obj.id,
        }
    })
    return cha
}
需要调用的方法
module.exports = {
    hello,hello1,hello2,hello3,hello4,hello5
}

　最后将表格的内容模块导入到models.js中

const mysql = require(‘./mysql‘)
//导入数据库
const Sequelize = require(‘sequelize‘)

//log表内数据格式
var Log = mysql.define(‘log‘, {
    id: {
        primaryKey: true,
        type: Sequelize.INTEGER,
    },
    content: Sequelize.STRING,
    summary: Sequelize.STRING,
    user: Sequelize.STRING,
    day: Sequelize.STRING,
}, {
        freezeTableName: true, // Model 对应的表名将与model名相同
        timestamps: false
});

//日志表内数据格式
var rizhi = mysql.define(‘rizhi‘, {
    id: {
        primaryKey: true,
        type: Sequelize.INTEGER,
    },
    content: Sequelize.STRING,
    summary: Sequelize.STRING,
    user: Sequelize.STRING,
    day: Sequelize.STRING,
}, {
        freezeTableName: true, // Model 对应的表名将与model名相同
        timestamps: false
});

调出两个表
module.exports = {Log,rizhi}

　　这就是一个完整的的node项目了，增删改查，以后就需要自己去扩展了

读写文件的话，就免不了书把txt，excel、sql、之间的数据转换，以后在讲。。。。。。

　

原文地址：https://www.cnblogs.com/yishifuping/p/9783917.html

时间： 2024-10-09 06:33:10

node.js从入门到放弃（一）的相关文章

node.js从入门到放弃《什么是node.js》

1.什么是node.js Node.js是一个后端的Javascript运行环境(支持的系统包括*nux.Windows),这意味着你可以编写系统级或者服务器端的Javascript代码. Node.js 使用事件驱动, 非阻塞I/O 模型而得以轻量和高效,非常适合在分布式设备上运行数据密集型的实时应用. 关于事件驱动的两个实例: 在美国去看医生,需要填写大量表格,比如保险.个人信息之类,传统的基于线程的系统(thread-based system),接待员叫到你,你需要在前台填写完成这些表格,

Node.js开发入门—使用对话框ngDialog

做网站经常会遇到弹出对话框获取用户输入或弹出对话框让用户确认某个操作之类的情景,有一个基于AngularJS的扩展模块可以帮我们优雅地完成这类事情:ngDialog. ngDialog在github上提供了一个示例网页,演示了它的各种用法,在这里:https://github.com/likeastore/ngDialog/blob/master/example/index.html.ngDialog的github主页的readme也对常用的指令和服务做了较为详细的介绍,可以参考.我这篇就纯粹是

Node.js开发入门—语音合成示例

出于项目需要,搞了一个语音合成(TTS)的小示例,使用的是OKVoice. 我想在PC上测试,OKVoice的快速接入API可以实现我的目的,文档在这里:http://dev.okvoice.com/file.php. 直接上代码吧,okVoiceTts.js,内容如下: var http = require('http'); var fs =require('fs'); var crypto = require('crypto'); var util = require('util'); va

Node.js开发入门—Stream用法详解

Stream是Node.js中非常重要的一个模块,应用广泛.一个流是一个具备了可读.可写或既可读又可写能力的接口,通过这些接口,我们可以和磁盘文件.套接字.HTTP请求来交互,实现数据从一个地方流动到另一个地方的功能. 所有的流都实现了EventEmitter的接口,具备事件能力,通过发射事件来反馈流的状态.比如有错误发生时会发射"error"事件,有数据可被读取时发射"data"事件.这样我们就可以注册监听器来处理某个事件,达到我们的目的. Node.js定义了R

Node.js开发入门—Angular简单示例

在"使用AngularJS"中,我们提到了如何在Node.js项目中引入AngularJS,这次提供一个非常简单的示例,演示AngularJS里的指令.数据绑定.服务等内容. 我准备做Web后台管理系统,不同的管理员会有不同的权限,管理员登录后看到的菜单和他的权限有关,能看到什么,是动态生成的(类似RBAC).本文的示例从这个项目而来,当然,现在还是最简单的. 如果没有特别说明,后面我们用到的示例都使用express generator生成. Angular小demo 先搞起来吧. 第

Node.js开发入门—UDP编程

Node.js也提供了UDP编程的能力,相关类库在"dgram"模块里. 与TCP不同,UDP是无连接的,不保障数据的可靠性,不过它的编程更为简单,有时候我们也需要它.比如做APP的统计或者日志或者流媒体,很多流媒体协议都会用到UDP,网上一搜一大堆. 使用UDP,如果你要发送数据,只需要知道对方的主机名(地址)和端口号,扔一消息过去即可.至于对方收不收得到,听天由命了.这就是数据报服务,类似快递或邮件. 我们这次来介绍一下Node.js里的UDP编程,我会提供一个UDP版本的echo

Node.js开发入门—使用http访问外部世界

Node.js的http模块,不但可以构建服务器,也可以作为客户端类库来访问别的服务器.关键就在两个方法: http.request(options[,callback]) http.get(path[,callback]) 除了http,还会用到FileSystem模块和Stream中的stream.Readable和stream.Writable. 先来大概介绍一下相关API吧. API解释 http.request()方法接受一个options参数,这个参数可以是对象,用来指明你要访问的网

Node.js开发入门—套接字(socket)编程

Node.js的net模块提供了socket编程接口,方便我们利用较为底层的套接字接口来实现应用协议.这次我们看一个简单的回显服务器示例,包括服务端和客户端的代码. 使用JavaScript也可以进行套接字编程,哈哈,这酸爽! 代码 分服务器和客户端两部分来说吧. echoServer代码分析 echoServer.js: var net = require("net"); // server is an instance of net.Server // sock is an ins

Node.js开发入门—notepad++ for Node.js

对于Node.js开发,论IDE的话,Webstorm是不二的选择,但它是收费的(可免费使用30天).一开始,我们先将就一下,使用notepad++来编写Node.js应用.这样做还有一大好处:没有关于Node.js的代码高亮和自动补全,可以更好地敦促我们使用在线API文档记忆各种类库API.死磕自己吧,enjoy it. notepad++的安装与配置 到"https://notepad-plus-plus.org/download/v6.8.2.html"这里下载吧,6.8.2版本