精华内容
下载资源
问答
  • thinkjs

    千次阅读 2015-09-05 22:37:31
    thinkjs入门 安装 npm install -g thinkjs-cmd 查看是否安装成功 thinkjs -v 新建项目 mkdir new_dir_name; cd new_dir_name; thinkjs . //正常到这里会自动打开浏览器页面访问项目 手动启动 node ...

    thinkjs

    入门

    • 安装
      npm install -g thinkjs-cmd

    • 查看是否安装成功
      thinkjs -v

    • 新建项目
      mkdir new_dir_name;
      cd new_dir_name;
      thinkjs . //正常到这里会自动打开浏览器页面访问项目
    • 手动启动
      node www\index.js

    配置

    thinkjs的配置有很多,系统默认配置 -> 应用配置 -> 调试配置 -> 模式配置
    基本上只用到应用配置,应用配置的路径是App/Conf/config.js
    配置在程序中是很方便读取和写入的

    //读取
    var dbHost = C('db_host');
    //写入
    C('name', 'xxx');
    C({
        'name': 'welefen',
        'use_cluster': false
    })

    系统默认配置路径:lib/Conf/config.js
    调试配置路径:App/Conf/debug.js
    模式配置路径:App/Conf/mode.js

    架构

    url中的含义

    一个典型的url:http://hostname:port/分组/控制器/操作/参数名/参数值/参数名2/参数值2?arg1=argv1&arg2=argv2
    分组 一个应用下有多个分组,一个分组都是很独立的模块。比如:前台模块、用户模块、管理员模块
    控制器一个分组下有多个控制器,一个控制器是多个操作的集合。如:商品的增删改查
    操作 一个控制器有多个操作,每个操作都是最小的执行单元。如:添加一个商品

    CBD模式

    CBD模式,核心Core+行为Behavior+驱动Driver

    核心(Core)

    thinkjs的核心部分包含通用函数库、系统默认配置、核心类库等组成,这些都是thinkjs必不可少的部分。

    lib/Common/common.js 通用函数库
    lib/Common/extend.js js原生对象的扩展
    lib/Common/function.js 框架相关的函数库
    lib/Conf/alias.js  系统类库别名,加载时使用
    lib/Conf/config.js 系统默认配置
    lib/Conf/debug.js debug模式下的配置
    lib/Conf/mode.js  不同模式下的配置
    lib/Conf/tag.js  每个切面下的行为
    lib/Lib/Core/App.js  应用核心库
    lib/Lib/Core/Controller.js 控制器基类
    lib/Lib/Core/Db.js  数据库基类
    lib/Lib/Core/Dispatcher.js 路由分发类
    lib/Lib/Core/Http.js 封装的http对象类
    lib/Lib/Core/Model.js 模型基类
    lib/Lib/Core/Think.js 框架类
    lib/Lib/Core/View.js 视图类
    lib/Lib/Util/Behavior.js 行为基类
    lib/Lib/Util/Cache.js 缓存基类
    lib/Lib/Util/Cookie.js cookie类
    lib/Lib/Util/Filter.js 数据过滤类
    lib/Lib/Util/Session.js session基类
    lib/Lib/Util/Valid.js 验证类
    
    行为(Behavior)

    行为是扩展机制里面特殊的扩展,它定义的是一个行为或者事件。
    标签是一组行为的集合,行为按顺序执行。
    系统的标签定义:
    - app_init 应用初始化
    - path_info 解析path路径
    - resource_check 静态资源请求检测
    - route_check 路由检测
    - app_begin 应用开始
    - action_init action初始化
    - view_init 视图初始化
    - view_template 模版定位
    - view_parse 模版解析
    - view_filter 模版内容过滤
    - view_end 视图结束
    - action_end action结束
    - app_end 应用结束

    系统配置如下(也可以在App/Conf/tag.js中自定义标签 ):

    /**
     * 系统标签配置
     * 可以在App/Conf/tag.js里进行修改
     * @type {Object}
     */
    module.exports = {
        //应用初始化
        app_init: [],
        //pathinfo解析
        path_info: [],
        //静态资源请求检测
        resource_check: ['CheckResource', 'CheckResourse2'],
    }

    驱动(Driver)

    除了核心和行为外,thinkjs里的很多功能都是通过驱动来实现的,如:Cache, Session, Db等。

    驱动包括:

    lib/Lib/Driver/Cache 缓存驱动
    lib/Lib/Driver/Db 数据库驱动
    lib/Lib/Driver/Session Session驱动
    lib/Lib/Driver/Socket Socket驱动
    lib/Lib/Driver/Template 模版引擎驱动
    如果有些功能框架里还没实现,如:mssql数据库,那么开发人员可以在项目里 App/Lib/Driver/Db/ 里实现。

    自动加载

    这里有thinkjs框架里面的文件,可以使用thinkRequire加载,非thinkjs里面的文件内部仍然是使用系统的require来加载
    可以快速加载的xxxBehavior, xxxModel,xxxController, xxxCache, xxxDb, xxxTemplate, xxxSocket, xxxSession

    路由

    路由定义了前端url到后端路径或者服务的一组映射规则,当访问http://hostname:port/分组/控制器/操作/参数名/参数值/参数名2/参数值2?arg1=argv1&arg2=argv2时,通过url.parse解析到的pathname为/分组/控制器/操作/参数名/参数值/参数名2/参数值2

    url过滤

    正常使用的url可能不是上面的/分组/控制器/操作/规则,可能有一些前缀或者后缀,通过如下配置可以修改。

    //url过滤配置
    'url_pathname_prefix': '', //前缀过滤配置
    'url_pathname_suffix': '.html' //后缀过滤配置

    路由识别

    通过上一步的url过滤之后,即可以按照/分组/控制器/操作/的方式来分割参数了,如果第一个路净值在分组列表中不存在,则第一个路径的值是分配到控制器上面。

    //分组列表
    'app_group_list': ["Home", "Admin"],
    'default_group': 'Home', //默认分组

    例:pathname为:/admin/group/list,会加载App/Lib/Controller/Admin/GroupController.js文件,实例化该类,并调用listAction方法。

    自定义路由

    可以通过自定义规则来配置,路由配置文件为:App/Conf/route.js

    //自定义路由规则
    module.exports = [
        ["规则1", "需要识别成的path"], //规则到具体pathname的映射
        ["规则2", {  //同一个规则根据不同的请求方式对应到不同的pathname上
            "get": "get请求时识别成的path", 
            "delete": "delete请求时识别成的path",
            "put,post": "put,post请求时识别成的path" //请求方式为put或者post时对应的pathname
        }]
    ]

    控制器

    控制器是分组下一类功能的集合,每个控制器是一个独立的类文件,每个控制器下有多个操作。

    定义控制器

    创建文件App/Lib/Controller/Home/ArticleController.js,表示Home分组下有名为Article的控制器。文件内容如下:

    //控制器文件定义
    module.exports = Controller(function(){
        return {
            indexAction: function(){
                return this.diplay();
            },
            listAction: function(){
                return this.display();
            },
            detailAction: function(){
                var doc = this.get("doc");
            }
        }
    });

    这里的控制器采用的是继承的方式,一些公用的操作可以写在基类中,非常方便。

    比如登录场景下的校验、获取导航的分类信息、常规的容错处理

    模型

    这里主要用来完成和持久层的数据库操作,如增删查改。

    定义一个模型

    这里也集成的是系统的model

    //模型定义
    module.exports = Model(function(){
        return {
            //获取用户列表
            getList: function(){
    
            }
        }
    })

    模型和数据表的映射

    模型的名称也是按驼峰约束,也是集成自系统的Model类。
    如模型名称是UserModel,对应的表名是user(假设没有表前缀)

    实例化

    //第一种
    //通过thinkRequire加载UserModel对应的js文件
    var userModel = thinkRequire("UserModel");
    var instance = userModel();
    //传递参数实例化
    var newInstance = userModel("users", {db_prefix: ""});
    
    //第二种
    //实例化模型类
    var model = D('User');

    支持链式操作

    var promise = D('User').where({name: 'user'}).field('sex,date').find().then(function(data){
        //data为当前查询到用户信息,如果没有匹配到相关的数据,那么data为一个空对象
    })

    小结

    说说对thinkjs的一些看法吧
    + 基于promise,有一套自己的规范。基于规范开发代码,代码会很清晰(按规范来写才好,如果随意发挥代码看着还是很痛苦的)
    + 有一整套自己的解决方案,方便快速搭建系统
    + 数据库的crud封装的很好,便于操作,使数据库底层操作对开发者透明,api很友好,可惜当前只支持mysql和mongodb

    总的来说,还是比较好用

    展开全文
  • ThinkJs入门

    千次阅读 2018-02-12 10:11:28
    TinkJs入门 本文是以thinkjs3.0版本为参照讲解的,如有不理解的部分,请参照:...全局安装thinkjs $ npm install -g think-cli 创建并执行项目 $ thinkjs new demo; $ cd demo; $ n...

    TinkJs入门

    本文是以thinkjs3.0版本为参照讲解的,如有不理解的部分,请参照:https://thinkjs.org/zh-cn/doc/3.0/create_project.html

    1.项目创建

    全局安装thinkjs

    $ npm install -g think-cli

    创建并执行项目

    $ thinkjs new demo;
    $ cd demo;
    $ npm install; 
    $ npm start;

    项目结构:

    |--- development.js   //开发环境下的入口文件
    |--- nginx.conf  //nginx 配置文件
    |--- package.json
    |--- pm2.json //pm2 配置文件
    |--- production.js //生产环境下的入口文件
    |--- README.md
    |--- src
    | |--- bootstrap  //启动自动执行目录 
    | | |--- master.js //Master 进程下自动执行
    | | |--- worker.js //Worker 进程下自动执行
    | |--- config  //配置文件目录
    | | |--- adapter.js  // adapter 配置文件 
    | | |--- config.js  // 默认配置文件 
    | | |--- config.production.js  //生产环境下的默认配置文件,和 config.js 合并 
    | | |--- extend.js  //extend 配置文件 
    | | |--- middleware.js //middleware 配置文件 
    | | |--- router.js //自定义路由配置文件
    | |--- controller  //控制器目录 
    | | |--- base.js
    | | |--- index.js
    | |--- service  //服务目录 
    | | |--- **.js //用户自己定义的服务
    | |--- logic //logic 目录
    | | |--- index.js
    | |--- model //模型目录
    | | |--- index.js
    |--- view  //模板目录
    | |--- index_index.html
    |--- www
    | |--- static  //静态资源目录
    | | |--- css
    | | |--- img
    | | |--- js

    默认情况下,项目启动端口为8360,执行成功后浏览器可通过http://127.0.0.1:8360/访问项目。

    2.路由(router)

    thinkjs的默认路由配置如下:

    module.exports = [
      {
        handle: 'router',
        options: {
          defaultModule: 'home',
          defaultController: 'index',
          defaultAction: 'index',
          prefix: [],
          suffix: ['.html'],
          enableDefaultRouter: true,
          subdomainOffset: 2,
          subdomain: {},
          denyModules: []
        }
      }
    ];

    我们可以手动在src/config/router.js下修改默认的配置。

    路由解析:

    默认情况下路由解析规则为:/controller/action

    多模块项目的解析规则为:/module/controller/action

    如果controller下有子级,那么解析规则为:/controller/子级/action。

    查找action时根据路由action名查找,如果未指定则查找indexAction。

    例如:

    http://127.0.0.1:8360/ :该路径请求controllerindex.js中的indexAction方法。

    http://127.0.0.1:8360/demo/demo:该路径请求controllerdemo子级的demo.js中的indexAction方法。

    3.控制器(controller)

    控制器主要是对用户的请求进行分发和处理。

    module.exports = class extends think.Controller {
        __before() {
            //action执行之前调用,如果返回false则不再执行action
        }
        async indexAction() {
            let data = await this.model('demo').select();
            return this.success(data);
            // return this.display();
        }
    
        demoAction() {
            const req = this.ctx.req;   //获取request
            const res = this.ctx.res;   //获取response
            return this.display("index_index.html");
        }
    
        __after() {
            //action 执行完成后执行,如果 action 返回了 false 则不再执行
        }
    
        __call() {
            //找不到对应的action时执行,可做统一处理
        }
    };
    

    4.数据校验层(Logic)

    通常情况下,服务端拿到数据后会先对数据进行正确性校验,才会进行之后的逻辑处理。所以thinkjs在controller之前加入了logic层,目的就是对数据进行校验。

    Logic中的Action必须和Controller中的Action一一对应。

    module.exports = class extends think.Logic {
      indexAction(){
        this.rules = {
          username: {
            string: true,       // 字段类型为 String 类型
            required: true,     // 字段必填
            default: 'thinkjs', // 字段默认值为 'thinkjs'
            trim: true,         // 字段需要trim处理
            method: 'GET'       // 指定获取数据的方式
          },
          age: {
            int: {min: 20, max: 60} // 20到60之间的整数
          }
        }
      }
    }

    logic会优先执行,校验成功后则进入controller进行逻辑处理。

    5.模型层(Modle)

    thinkjs在src/config/extend.js已经通过model(think.app)引入了所有的关联模型,所以不需要我们做特殊处理。在该模块中可以定义一些实体或者存储一些复杂的数据查询方法。

    6.视图层(View)

    配置 src/config/extend.js来支持View

    const view = require('think-view');
    module.exports = [
      view
    ]

    配置 src/config/adapter.js设置视图默认配置

    const nunjucks = require('think-view-nunjucks');
    const path = require('path');
    
    // 视图的 adapter 名称为 view
    exports.view = {
      type: 'nunjucks', // 这里指定默认的模板引擎是 nunjucks
      common: {
        viewPath: path.join(think.ROOT_PATH, 'view'), //模板文件的根目录
        sep: '_', //Controller 与 Action 之间的连接符
        extname: '.html' //模板文件扩展名
      },
      nunjucks: {
        handle: nunjucks,
        beforeRender: () => {}, // 模板渲染预处理
        options: { // 模板引擎额外的配置参数
    
        }
      }
    }

    三个与视图相关的重要方法:

    assign:给模版赋值。

    //单条赋值
    this.assign('title', 'thinkjs'); 
    
    //多条赋值
    this.assign({
      title: 'thinkjs', 
      name: 'test'
    }); 
    
    //获取之前赋过的值,如果不存在则为 undefined
    const title = this.assign('title'); 
    
    //获取所有赋的值
    const assignData = this.assign();

    render:获取渲染后的内容。

    该方法是异步方法,需要通过asyns/await来处理。

    //根据当前请求解析的 controller 和 action 自动匹配模板文件
    const content1 = await this.render(); 
    
    //指定文件名
    const content2 = await this.render('doc'); 
    const content3 = await this.render('doc/detail'); 
    const content4 = await this.render('doc_detail');
    
    //不指定文件名但切换模板类型
    const content5 = await this.render(undefined, 'ejs');
    
    //指定文件名且切换模板类型
    const content6 = await this.render('doc', 'ejs'); 
    
    //切换模板类型,并配置额外的参数
    //切换模板类型时,需要在 adapter 配置里配置对应的类型
    const content7 = await this.render('doc', {
      type: 'ejs', 
      xxx: 'yyy'
    });

    display:渲染并输出内容,该方法实际上是调用了 render 方法,然后将渲染后的内容赋值到 ctx.body 属性上。该方法为异步方法,需要通过 async/await 处理。

    //根据当前请求解析的 controller 和 action 自动匹配模板文件
    await this.display(); 
    
    //指定文件名
    await this.display('doc'); 
    await this.display('doc/detail'); 
    await this.display('doc_detail');
    
    //不指定文件名切换模板类型
    await this.display(undefined, 'ejs');
    
    //指定文件名且切换模板类型
    await this.display('doc', 'ejs'); 
    
    //切换模板类型,并配置额外的参数
    await this.display('doc', {
      type: 'ejs', 
      xxx: 'yyy'
    });

    7.中间件配置(middleware)

    中间件是为了更方便的处理用户请求,Thinkjs3是基于Koa2构建的。所以中间件的处理格式为:

    module.exports = options => {
      return (ctx, next) => {
        // do something
      }
    }

    在Koa2中要使用中间件需通过app.use(‘中间件’)的方式。

    为了更加统一的维护和管理中间件,所以Thinjs3提供了src/config/middleware.js文件进行中间件配置。

    const path = require('path');
    const isDev = think.env === 'development';
    
    module.exports = [
      {
        handle: 'meta',
        options: {
          logRequest: isDev,
          sendResponseTime: isDev
        }
      },
      {
        handle: 'resource',                             //中间件的处理函数
        enable: isDev,                                  //是否启用中间件
        options: {                                      //中间件配置参数,可以是一个函数
          root: path.join(think.ROOT_PATH, 'www'),      
          publicPath: /^\/(static|favicon\.ico)/
        },
         match:'/www/static'                            //匹配特定的规则后才能执行中间件,可以是路径或匹配函数
      }
    ]

    8.数据库配置

    模型支持多种多个数据库的,其配置路径为src/config/adapter.js

    const mysql = require('think-model-mysql');
    exports.model = {
      type: 'mysql', // 默认使用的类型,调用时可以指定参数切换
      common: { // 通用配置
        logConnect: true, // 是否打印数据库连接信息
        logSql: true, // 是否打印 SQL 语句
        logger: msg => think.logger.info(msg) // 打印信息的 logger
      },
      mysql: { // mysql 配置
        handle: mysql
      },
      mysql2: { // 另一个 mysql 的配置
        handle: mysql
      },
      sqlite: {  // sqlite 配置
    
      },
      postgresql: { // postgresql 配置
    
      }
    }

    当项目用到多个数据库的时候,可以通过type来区分。

    const user1 = think.model(‘user’); // 使用默认的数据库配置

    const user2 = think.model(‘user’, ‘mysql2’); // 使用 mysql2 的配置

    9.系统服务启动流程

    这里写图片描述

    10.用户请求流程

    这里写图片描述

    展开全文
  • thinkjs使用事务

    万次阅读 2020-08-02 23:36:53
    首先需要警告下朋友们,千万别去thinkjs官网群里面去问那些大佬,个别大佬的脾气是真的惹不起系列。比如: 行了,不扯没用的了,但是说实话真的是在官网群里面被气死了。这个项目之后再也不用thinkjs了。【手动...

    首先需要警告下朋友们,千万别去thinkjs官网群里面去问那些大佬,个别大佬的脾气是真的惹不起系列。比如:


    在这里插入图片描述
    在这里插入图片描述

    行了,不扯没用的了,但是说实话真的是在官网群里面被气死了。【手动微笑】

    下文当中有任何疑问问题请在评论区评论,笔者会在第一时间回复。或者进入笔者技术交流群互动:react:815413387,vue:942347564,JAVA:830645840。

    1.model中使用手工操作事务

    async addData(data) {
      // 如果添加成功则 commit,失败则 rollback
      try {
        await this.startTrans();
        const result = await this.add(data);
        await this.commit();
        return result;
      } catch(e){
        await this.rollback();
      }
    }
    

    2.model中使用transaction

    async updateData(data){
      const result = await this.transaction(async () => {
        const insertId = await this.add(data);
        // 通过 db 方法让 other_model 模型复用当前模型的数据库连接
        const otherModel = this.model('other_model').db(this.db());
        const addRes = await otherModel.add({user_id: insertId, cate_id: 100});
        return addRes;
      })
    }
    

    3.controller中使用手工操作事务

    async xxxAction() {
    	const data = this.post();
    	// 一定要保证三个或N个在一次连接中进行
    	const salesRecord = this.ctx.model('sales_record');
    	const salesRecordItem = this.ctx.model('sales_record_item').db(salesRecord.db());
    	const members = this.ctx.model('members').db(salesRecord.db());
    	
    	// 使用try catch捕捉错误
    	try {
    	  await salesRecord.startTrans(); // 开启事务
    	  const submitRecordRes = await salesRecord.submitSalesRecord(data);
    	  await salesRecordItem.addMany(data.items);
    	  await salesRecord.commit(); // 一切正常就提交
    	} catch (e) {
    	  await salesRecord.rollback(); // 出错了就rollback
    	}
    }
    

    4.controller中使用transaction

    async xxxAction() {
    	const data = this.post();
    	// 一定要保证三个或N个在一次连接中进行
    	const salesRecord = this.ctx.model('sales_record');
    	const salesRecordItem = this.ctx.model('sales_record_item').db(salesRecord.db());
    	const members = this.ctx.model('members').db(salesRecord.db());
    	
    	// 开始事务
    	await salesRecord.transaction(async() => {
    	  // 捕捉异常
          try {
            await members.updateMember(data);
            await salesRecord.submitSalesRecord(data);
            // 提交最后的结果,如果最后成功了那就会执行commit,失败了会rollback
            return await salesRecordItem.addMany(data.items);
          } catch (e) { // 出错了就rollback
            await salesRecord.rollback();
          }
        });
    }
    

    查看最后的结果

    这是成功了走的commit
    在这里插入图片描述
    这是失败了走的rollback
    在这里插入图片描述

    有啥问题评论区交流吧~

    展开全文
  • 之前用thinkjs帮朋友写了个毕业设计 第一次用中国的nodejs后端框架来写服务端 一开始上手thinkjs 打开thinkjs的文档 thinkjs 感觉对刚刚上手的开发者很友好 有着非常详细的文档 而且thinkjs是基于koa2的 所以一些koa...

    之前用thinkjs帮朋友写了个毕业设计
    第一次用中国的nodejs后端框架来写服务端

    一开始上手thinkjs
    打开thinkjs的文档
    thinkjs
    感觉对刚刚上手的开发者很友好
    有着非常详细的文档
    而且thinkjs是基于koa2的
    所以一些koa2可以用的API在thinkjs的框架上也一样可以使用

    但是我们在网上搜索一下thinkjs相关的博客
    会发现使用的人确实还不多
    所以预先准备好会踩坑的准备

    1.安装

    安装这一块可以参照一下文档,基本上不会遇到什么坑
    作为一个前端工程师,用npm安装thinkjs可以说是像喝水一样很平常的事情

    2.项目目录

    |--- development.js   //开发环境下的入口文件
    |--- nginx.conf  //nginx 配置文件
    |--- package.json
    |--- pm2.json //pm2 配置文件
    |--- production.js //生产环境下的入口文件
    |--- README.md
    |--- src
    | |--- bootstrap  //启动自动执行目录 
    | | |--- master.js //Master 进程下自动执行
    | | |--- worker.js //Worker 进程下自动执行
    | |--- config  //配置文件目录
    | | |--- adapter.js  // adapter 配置文件 
    | | |--- config.js  // 默认配置文件 
    | | |--- config.production.js  //生产环境下的默认配置文件,和 config.js 合并 
    | | |--- extend.js  //extend 配置文件 
    | | |--- middleware.js //middleware 配置文件 
    | | |--- router.js //自定义路由配置文件
    | |--- controller  //控制器目录 
    | | |--- base.js
    | | |--- index.js
    | |--- logic //logic 目录
    | | |--- index.js
    | |--- model //模型目录
    | | |--- index.js
    |--- view  //模板目录
    | |--- index_index.html
    

    我认为初初认识一个框架,项目目录是非常重要的
    可以初步认识和了解到框架设计者的设计思想
    我们可以看到整个项目的层次非常清晰

    由于朋友的毕业设计是前后端分离的项目,前端采用的vue,后端采用的是thinkjs,通过接口请求的方式建立连接
    所以这个view文件夹里我们就不放任何的前端文件了

    按照我的个人习惯
    我会再建一个service层文件夹,与model文件夹同级,担当业务层,而controller 就做为简简单单的表示层
    (可能有的人会说有点多余,controller 处理业务逻辑也完全没问题,但是我还是喜欢把处理业务逻辑的部分划分得清楚一下)

    再thinkjs中,没有数据访问层的文件夹(类比springboot),是因为thinkjs已经把对数据库进行操作都封装成了API
    只要在service层实例化数据表对应的model

            const order = this.model('order')
            const data = await order.where({id:id}).select();
    

    便可以进行对数据进行你们想要的CRUD

    在thinkjs中,有两个比较值得注意的特点

    Middleware / 中间件
    在文档中是这样去解释Middleware的
    中间件

    在这里插入图片描述
    这个洋葱模型就非常经典的解释了整个中间件的处理过程
    从接收到request到返回Response
    可以在中间件中处理整个请求的生命周期
    可以在请求生命周期中做任何想要的操作
    “万物皆可中间件”
    这是我的师兄在给我介绍koa的中间件概念时说的
    放到thinkjs里也同样适用

    Logic
    官方概念
    Logic

    这是官方提供的一个概念
    为了不让controller 里的action的逻辑代码过于复杂且冗长
    我们可以把对数据的检验和权限的判断放在Logic层,在处理请求前
    需要经过Logic层的处理,通过后便到达controller层
    这也是thinkjs为了避免开发者在action里写入过多逻辑代码所精心设计的

    好了,入门的理解暂时介绍到这里
    这个博客还会继续更新
    把个人开发中的一些理解写在这里
    谢谢

    展开全文
  • ThinkJS安装

    千次阅读 2018-08-03 17:32:20
    本文摘抄于 ThinkJS官方文档2.2版本 ThinkJS 是一款 Node.js 的 MVC 框架,所以安装 ThinkJS 之前,需要先安装 Node.js 环境。ThinkJS 需要 Node.js 的版本 >=0.12.0,如果版本小于这个版本,需要升级 Node...
  • WebStorm调试ThinkJS

    2018-12-03 15:48:55
    使用WebStorm调试ThinkJS,适用于目前最新的WebStorm 2018.3版本
  • ThinkJS 简介

    千次阅读 2017-10-15 17:32:28
    简介最近几年,前端技术呈现出突飞猛进的发展,涌现出了一大批优秀...而作为一款优秀的国产前端框架,ThinkJS整合了大量的项目最佳实践,让企业级开发变得更加简单、高效。从 3.0 开始,框架底层基于 Koa 2.x 实现,兼
  • ThinkJS LOGO Design

    2021-01-12 16:02:31
    <div><p>欢迎贡献 ThinkJS LOGO 设计,请提供矢量图</p><p>该提问来源于开源项目:thinkjs/thinkjs</p></div>
  • thinkJS入门

    2019-12-17 14:54:22
    官网快速入门教程:https://thinkjs.org/zh-cn/doc/3.0/create_project.html 到了这里项目就已经启动了。 下面要说的是controller 页面访问:http://localhost:8360/user?name=xili 打印日志: post参数...
  • ThinkJS 模块

    2018-08-03 17:34:13
    本文摘抄于 ThinkJS官方文档2.2版本  模块 ThinkJS 创建项目时支持多种项目模式,默认创建的项目是按模块来划分的,并且自动添加了 common 和 home 2 个模块。每个模块有独立的配置、控制器、视图、模型等...
  • 根据官网直接执行安装命令 npm install -g think-cli 报以下错误 -bash: node: command not found 执行下面两句安装nodejs ...udo yum install epel-release ...查看thinkjs是否安装成功 thinkjs --version 创
  • thinkjs module 报错

    2021-01-12 17:49:18
    thinkjs module 模块名 , 会报错 <h3>ENV <p>OS Platform:macOS 10.12.5 <p>Node.js Version: v8.9.4 <p>Think-cli Version:2.2.3 <h3>code <pre><code>js // your code here </code></pre> <h3>error ...
  • ThinkJS 3.0 断点调试

    2021-01-12 18:38:58
    <p>thinkjs3.0 beta3 用<code>thinkjs new demo</code> 生成的项目,在webstorm里面点击 调试 development.js 不能启动 <h2>ENV <p>development Platform: mac Node.js Version: 8.1.4 ThinkJS Version: 3.0 ...
  • 使用thinkjs的产品

    2021-01-12 16:00:52
    <div><p>已经在使用thinkjs的产品可以在这里列出</p><p>该提问来源于开源项目:thinkjs/thinkjs</p></div>
  • thinkjs简单demo v1.0

    2020-10-06 05:30:53
    基于thinkjs的简单demo,包括登录注册,信息发布/编辑/删除 使用本产品需要以下知识:Nodejs、thinkjs、ejs、mysql、html、css、jquery 供学习使用,只完成了基本功能,未做界面和程序上的进一步优
  • thinkjs 安装笔记

    2019-09-26 16:22:09
    thinkjs 安装笔记 1.首先安装thinkjsnpm install -g thinkjs(-g是指全局安装)检查是否安装成功:thinkjs -v 2.创建项目进入项目目录,初始化项目:thinkjs new project_path(project_pa...
  • thinkjs 2.0需求收集

    2021-01-12 16:06:20
    <div><p>今年会开发thinkjs 2.0版本,这里收集大家需求,欢迎提各种意见。</p><p>该提问来源于开源项目:thinkjs/thinkjs</p></div>
  • Thinkjs 邮件群发 v1.0

    2019-10-28 02:28:25
    安装:1 安装nodejs、thinkjs2 修改index控制器下的index方法,添加自己的发送方邮箱和密码3 参考thinkjs官方文档所示启动方式进行启动4 邮件列表可以手动在/www/resource/maillist.txt文件里面添加,每行一个邮件地址...
  • ThinkJS 是一款面向未来开发的 Node.js 框架,整合了大量的项目最佳实践,让企业级开发变得如此简单、高效。接下来通过本文给大家分享thinkjs 文件上传功能,需要的朋友参考下吧
  • thinkjs操作数据库

    2020-07-09 23:19:31
    thinkjs操作数据库 1.进入目录demo1/src/config/adapter.js文件 mysql: { handle: mysql, database: 'thinkjs', prefix: '', encoding: 'utf8', host: '127.0.0.1', port: '', user: 'root', password: '...
  • vue20全家桶thinkjs框架

    2019-08-10 11:30:10
    vue2.0全家桶 thinkjs框架
  • 最近将一个cms系统从ThinkJS2.x迁移到ThinkJS3.x过程中发现以前使用的think对象内置的方法依然有效,比如think.md5()、think.uuid()、think.isEmpty()等等。 这些在ThinkJS3.0文档中的think对象描述部分并没...
  • ThinkJs笔记琐碎

    2019-04-01 10:17:00
    ThinkJs笔记琐碎 记录一些琐碎的在使用ThinkJs遇到的问题 静态资源访问 ThinkJs默认production环境关闭对www下资源的相对路径的访问,官方建议通过nginx转向的地址的绝对路径访问,想要在production环境访问相对...
  • thinkjs接收get请求、post请求

    万次阅读 2020-07-03 17:38:35
    此文介绍使用 thinkjs 如何获取前端的请求参数。 文章目录笔者使用环境:服务端对前端请求进行校验服务端接收前端的请求参数GET请求POST请求 笔者使用环境: 服务端:thinkjs 前端:react 请求:umi-request 服务端...
  • thinkjs.org is down

    2021-01-12 16:03:19
    <div><p>该提问来源于开源项目:thinkjs/thinkjs</p></div>
  • 这个个人博客网站最初制作的目的就是练习使用thinkJs,这一篇就主要讲一下thinkJs的一些特性和注意事项。涉及到了文件上传,thinkJs的插件机制,model层建立以及CURD的编写方式等。本项目github地址在这里。 项目...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,067
精华内容 426
关键字:

thinkjs