EOS开发实战


  在上一篇文章《EOS开发入门》中，我们为大家介绍了EOS的节点启动和合约部署和调用等入门知识。本次我们来实现一个复杂的例子，可以为其取一个高大上的名字-悬赏任务管理系统。这可以是我们身边的一个例子，在工作中我们也许会碰到需要周围人帮助实现工作以外的问题，这往往需要靠交情来做到。我们使用eos可以实现这样一个任务管理系统，任务发起人可以发布一个任务给某个赏金猎人，指定任务的赏金。在任务完成后，发起人将约定的赏金交给完成者。

1. 合约设计

  通过故事背景介绍，我们可以察觉我们需要支付赏金的部分，这个可以使用区块链的token来实现。另外还需要一个实现一个对任务的管理，token的实现可以直接使用eosio.token，任务的管理我们需要实现3个action，创建任务，提交任务，验收任务。总结如下：

  • token合约：创建，发行，转账

  • task合约：创建，提交，验收

2. 合约实现

任务需要包含的信息：

  1. struct [[eosio::table]] task {
  2.          uint64_t    taskID;//任务编号
  3.          name        creator; //创建者
  4.          name        worker;//执行者
  5.          asset       bonus;//承诺奖励
  6.          uint8_t     status = 0;//状态
  7.          string      remark;//任务描述
  8.          string      comment;//评价
  10.          uint64_t primary_key()const { return taskID; }
  11.       };

2.1 token合约

  • pdjtoken.hpp
  1. /**
  2.  *  @file pdjtoken.hpp
  3.  *  @company http://pdjedu.com/
  4.  */
  5. #pragma once
  7. #include <eosiolib/asset.hpp>
  8. #include <eosiolib/eosio.hpp>
  10. #include <string>
  12. namespace eosiosystem {
  13.    class system_contract;
  14. }
  16. namespace eosio {
  18.    using std::string;
  20.    class [[eosio::contract("pdjtoken")]] pdjtoken : public contract {
  21.       public:
  22.          using contract::contract;
  23.          pdjtoken(name receiver, name code,  datastream<const char*> ds): contract(receiver, code, ds) {}
  25.          [[eosio::action]]
  26.          void create( name   issuer,
  27.                       asset  maximum_supply);
  29.          [[eosio::action]]
  30.          void issue( name to, asset quantity, string memo );
  32.          [[eosio::action]]
  33.          void transfer( name    from,
  34.                         name    to,
  35.                         asset   quantity,
  36.                         string  memo );
  38.       private:
  40.          inline asset get_supply( name token_contract_account, symbol_code sym_code )const;
  42.          inline asset get_balance( name token_contract_account, name owner, symbol_code sym_code )const;
  44.       private:
  46.          struct [[eosio::table]] account {
  47.             asset    balance;
  49.             uint64_t primary_key()const { return balance.symbol.code().raw(); }
  50.          };
  52.          struct [[eosio::table]] currency_stats {
  53.             asset    supply;
  54.             asset    max_supply;
  55.             name     issuer;
  57.             uint64_t primary_key()const { return supply.symbol.code().raw(); }
  58.          };
  60.          typedef eosio::multi_index< "accounts"_n, account > accounts;
  61.          typedef eosio::multi_index< "stat"_n, currency_stats > stats;
  63.          void sub_balance( name owner, asset value );
  64.          void add_balance( name owner, asset value, name ram_payer );
  65.    };
  67. asset pdjtoken::get_supply( name token_contract_account, symbol_code sym_code )const
  68. {
  69.    stats statstable( token_contract_account, sym_code.raw() );
  70.    const auto& st = statstable.get( sym_code.raw() );
  71.    return st.supply;
  72. }
  74. asset pdjtoken::get_balance( name token_contract_account, name owner, symbol_code sym_code )const
  75. {
  76.    accounts accountstable( token_contract_account, owner.value );
  77.    const auto& ac = accountstable.get( sym_code.raw() );
  78.    return ac.balance;
  79. }
  81. } /// namespace eosio
  • pdjtoken.cpp
  1. /**
  2.  *  @file pdjtoken.cpp
  3.  *  @copyright http://pdjedu.com/
  4.  */
  6. #include "pdjtoken.hpp"
  8. namespace eosio {
  10. //创建
  11. void pdjtoken::create( name   issuer,
  12.                     asset  maximum_supply )
  13. {
  14.     require_auth( _self );
  16.     auto sym = maximum_supply.symbol;
  17.     eosio_assert( sym.is_valid(), "invalid symbol name" );
  18.     eosio_assert( maximum_supply.is_valid(), "invalid supply");
  19.     eosio_assert( maximum_supply.amount > 0, "max-supply must be positive");
  21.     stats statstable( _self, sym.code().raw() );
  22.     auto existing = statstable.find( sym.code().raw() );
  23.     eosio_assert( existing == statstable.end(), "token with symbol already exists" );
  25.     statstable.emplace( _self, [&]( auto& s ) {
  26.        s.supply.symbol = maximum_supply.symbol;
  27.        s.max_supply    = maximum_supply;
  28.        s.issuer        = issuer;
  29.     });
  30. }
  32. //发行
  33. void pdjtoken::issue( name to, asset quantity, string memo )
  34. {
  35.     auto sym = quantity.symbol;
  36.     eosio_assert( sym.is_valid(), "invalid symbol name" );
  37.     eosio_assert( memo.size() <= 256, "memo has more than 256 bytes" );
  39.     stats statstable( _self, sym.code().raw() );
  40.     auto existing = statstable.find( sym.code().raw() );
  41.     eosio_assert( existing != statstable.end(), "token with symbol does not exist, create token before issue" );
  42.     const auto& st = *existing;
  44.     require_auth( st.issuer );
  45.     eosio_assert( quantity.is_valid(), "invalid quantity" );
  46.     eosio_assert( quantity.amount > 0, "must issue positive quantity" );
  48.     eosio_assert( quantity.symbol == st.supply.symbol, "symbol precision mismatch" );
  49.     eosio_assert( quantity.amount <= st.max_supply.amount - st.supply.amount, "quantity exceeds available supply");
  51.     statstable.modify( st, same_payer, [&]( auto& s ) {
  52.        s.supply += quantity;
  53.     });
  55.     add_balance( st.issuer, quantity, st.issuer );
  57.     if( to != st.issuer ) {
  58.       SEND_INLINE_ACTION( *this, transfer, { {st.issuer, "active"_n} },
  59.                           { st.issuer, to, quantity, memo }
  60.       );
  61.     }
  62. }
  64. //转账
  65. void pdjtoken::transfer( name    from,
  66.                       name    to,
  67.                       asset   quantity,
  68.                       string  memo )
  69. {
  70.     eosio_assert( from != to, "cannot transfer to self" );
  71.     require_auth( from );
  72.     eosio_assert( is_account( to ), "to account does not exist");
  73.     auto sym = quantity.symbol.code();
  74.     stats statstable( _self, sym.raw() );
  75.     const auto& st = statstable.get( sym.raw() );
  77.     require_recipient( from );
  78.     require_recipient( to );
  80.     eosio_assert( quantity.is_valid(), "invalid quantity" );
  81.     eosio_assert( quantity.amount > 0, "must transfer positive quantity" );
  82.     eosio_assert( quantity.symbol == st.supply.symbol, "symbol precision mismatch" );
  83.     eosio_assert( memo.size() <= 256, "memo has more than 256 bytes" );
  85.     auto payer = has_auth( to ) ? to : from;
  87.     sub_balance( from, quantity );
  88.     add_balance( to, quantity, payer );
  89. }
  91. void pdjtoken::sub_balance( name owner, asset value ) {
  92.    accounts from_acnts( _self, owner.value );
  94.    const auto& from = from_acnts.get( value.symbol.code().raw(), "no balance object found" );
  95.    eosio_assert( from.balance.amount >= value.amount, "overdrawn balance" );
  97.    from_acnts.modify( from, owner, [&]( auto& a ) {
  98.          a.balance -= value;
  99.       });
  100. }
  102. void pdjtoken::add_balance( name owner, asset value, name ram_payer )
  103. {
  104.     accounts to_acnts( _self, owner.value );
  105.     auto to = to_acnts.find( value.symbol.code().raw() );
  106.     if( to == to_acnts.end() ) {
  107.        to_acnts.emplace( ram_payer, [&]( auto& a ){
  108.          a.balance = value;
  109.        });
  110.     } else {
  111.        to_acnts.modify( to, same_payer, [&]( auto& a ) {
  112.          a.balance += value;
  113.        });
  114.     }
  115. }
  117. } /// namespace eosio
  119. EOSIO_DISPATCH( eosio::pdjtoken, (create)(issue)(transfer) )

2.2 task合约

  • pdjtask.hpp
  1. /**
  2.  *  @file pdjtask.hpp
  3.  *  @company http://pdjedu.com/
  4.  */
  5. #pragma once
  7. #include <eosiolib/asset.hpp>
  8. #include <eosiolib/eosio.hpp>
  10. #include <string>
  12. namespace eosiosystem {
  13.    class system_contract;
  14. }
  16. namespace eosio {
  18.    using std::string;
  20. class [[eosio::contract]] pdjtask : public contract {
  21.    public:
  22.       pdjtask(name receiver, name code,  datastream<const char*> ds): contract(receiver, code, ds) {}
  24.       //创建任务
  25.       [[eosio::action]]
  26.       void createtk( name creator, name worker, asset taskBonus, string memo );
  27.       //提交任务
  28.       [[eosio::action]]
  29.       void commit( uint64_t taskID, string memo );
  30.       //验收任务
  31.       [[eosio::action]]
  32.       void confirm( uint64_t taskID, uint8_t ok = 1 );
  34.    private:
  36.       struct [[eosio::table]] task {
  37.          uint64_t    taskID;
  38.          name        creator;
  39.          name        worker;
  40.          asset       bonus;
  41.          uint8_t     status = 0;
  42.          string      remark;
  43.          string      comment;
  45.          uint64_t primary_key()const { return taskID; }
  46.       };
  48.       typedef eosio::multi_index< "tasks"_n, task > tasks;
  49.    private:
  51.       /*
  52.       void transfer( name    from,
  53.                         name    to,
  54.                         asset   quantity,
  55.                         string  memo );
  57.       */
  59.    void task_commit(name from, name to, asset bonus, string memo) {
  61.     action act = action(
  62.       permission_level{from,"active"_n},
  63.       "pdjtoken"_n,
  64.       "transfer"_n,
  65.       std::make_tuple(from, to, bonus, memo)
  66.     );
  68.     act.send();
  69.   }
  70. };
  72. } /// namespace eosio
  • pdjtask.cpp
  1. /**
  2.  *  @file pdjtask.cpp
  3.  *  @company http://pdjedu.com/
  4.  */
  6. #include "pdjtask.hpp"
  8. namespace eosio {
  10. //创建任务
  11. void pdjtask::createtk( name creator, name worker, asset taskBonus, string memo )
  12. {
  13.     require_auth(creator);
  14.     //require_auth(worker);
  16.     auto sym = taskBonus.symbol;
  17.     eosio_assert( sym.is_valid(), "invalid symbol name" );
  19.     tasks tk( _code, _code.value );
  21.     tk.emplace( creator, [&](auto &t){
  22.         t.creator = creator;
  23.         t.worker  = worker;
  24.         t.taskID  = tk.available_primary_key();
  25.         t.bonus   = taskBonus;
  26.         t.remark  = memo;
  27.     });
  28. }
  29. //提交任务
  30. void pdjtask::commit( uint64_t taskID, string memo )
  31. {
  32.     //提交任务者必须与任务分配者是一个人
  33.     print("hi,",name{_self});
  34.     //require_auth(worker);
  35.     tasks tk( _code, _code.value );
  36.     auto tkobj = tk.find(taskID);
  37.     eosio_assert( tkobj != tk.end(), "taskid not exists" );
  38.     require_auth(tkobj->worker );
  39.     //eosio_assert( tkobj->worker == worker, "worker not same" );
  40.     tk.modify(tkobj, tkobj->worker ,[&](auto &t){
  41.         t.status = 1;
  42.         t.comment = memo;
  43.     });
  45. }
  47. //验收任务
  48. void pdjtask::confirm( uint64_t taskID, uint8_t ok )
  49. {
  50.     //require_auth(creator);
  51.     tasks tk( _code, _code.value );
  52.     auto tkobj = tk.find(taskID);
  53.     eosio_assert( tkobj != tk.end(), "taskid not exists" );
  54.     uint8_t status = 2;
  55.     print("confirm---",name{tkobj->creator});
  56.     require_auth(tkobj->creator);
  57.     if ( !ok ) {
  58.         // re do
  59.         status = 0;
  60.     }
  61.     tk.modify(tkobj, tkobj->creator, [&](auto &t){
  62.         t.status = status;
  63.         t.comment = "well done!";
  64.     });
  66.     if ( ok ){
  67.         //发币刺激
  68.         //transfer( creator, tkobj->worker, tkobj->bonus, "very good!" );
  69.         task_commit(tkobj->creator, tkobj->worker, tkobj->bonus, "very good!");
  70.     }
  72. }
  74. } /// namespace eosio
  76. EOSIO_DISPATCH( eosio::pdjtask, (createtk)(commit)(confirm) )

3. eosjs调用合约

  在合约编写完成后，我们还需要编写一个页面来调用智能合约，这就需要用到eosjs。eosjs集成了EOSIO RPC API，用于与EOS区块链交互，查阅官方文档可获取更多详细信息。



monkeysun和laowang已经收到了任务奖励的token

3.1 核心代码

  • index.js
  1. $(function() {
  2.     var userAccount;
  3.     var userPrivateKey;
  4.     $("#LoginWindow").modal();
  6.     $(".Login").on("click", function() {
  7.         userAccount = $("#userAcc").val();
  8.         userPrivateKey = $("#PrivateKey").val();
  10.         config = {
  11.             chainId: 'cf057bbfb72640471fd910bcb67639c22df9f92470936cddc1ade0e2f2e7dc4f', // 32 byte (64 char) hex string
  12.             keyProvider: [userPrivateKey], // WIF string or array of keys..   //5J2ZC6ZbtoFnTsZofTnMaTQmZSkdx9DnM9QZbuYTvDS2AgQaGzX
  13.             httpEndpoint: 'http://127.0.0.1:8888',
  14.             expireInSeconds: 60,
  15.             broadcast: true,
  16.             verbose: false, // API activity
  17.             sign: true
  18.         }
  19.         eos = Eos(config);
  21.         eos.getAccount(userAccount).then(result => {
  22.             console.log(result);
  23.             alert("欢迎回来，" + userAccount);
  24.             $(".userName span:nth-child(2)").html("账户：" + userAccount);
  25.             getBalance();
  26.         }).catch(err => {
  27.             console.log(err);
  28.             alert("错误：账户不存在！");
  29.         });
  31.         $(".close_win").click();
  32.         getTaskList();
  33.     });
  35.     //发布任务
  36.     $(".Createtk").on("click", function() {
  37.         console.log("发布任务");
  38.         console.log(userPrivateKey);
  39.         $("#ReleaseTask").modal();
  40.         getTaskList();
  41.     });
  42.     //确认发布任务
  43.     $(".ConfirmRelease").on("click", function() {
  44.         var WorkerAcc  = $("#GetWorker").val();
  45.         var TaskToken  = $("#GetToken").val();
  46.         var TaskInfo   = $("#GetTaskInfo").val();
  47.         console.log(WorkerAcc,TaskToken,TaskInfo);
  48.         $(".close_win").click();
  50.         eos.transaction({
  51.             actions: [
  52.             {
  53.                 account: 'pdjtask',
  54.                 name:    'createtk',
  55.                 authorization: [{
  56.                     actor:      userAccount,
  57.                     permission: 'active'
  58.                 }],
  60.                 data: {
  61.                     creator:    userAccount,
  62.                     worker:     WorkerAcc,
  63.                     taskBonus:  TaskToken,
  64.                     memo:       TaskInfo
  65.                 }
  66.             }
  67.             ]
  68.         }).then(result => {
  69.                                 console.log(result);
  70.                                 alert("发布成功！");
  71.                                 getTaskList();
  72.                           })
  73.           .catch(error => {console.error(error);alert("发生错误！" + error)});
  74.     });
  76.     //领取任务
  77.     $(".Receive").on("click", function() {
  78.         console.log("领取任务");
  79.         $("#ReceiveTask").modal();
  80.         getTaskList();
  81.     });
  82.     //确认领取
  83.     $(".ConfirmReceive").on("click", function() {
  84.         var TaskID = $("#ReceiveTaskID").val();
  85.         console.log(TaskID);
  86.         $(".close_win").click();
  88.         eos.transaction({
  89.             actions: [
  90.             {
  91.                 account: 'pdjtask',
  92.                 name:    'receivetk',
  93.                 authorization: [{
  94.                     actor:      userAccount,
  95.                     permission: 'active'
  96.                 }],
  98.                 data: {
  99.                     taskID:     TaskID,
  100.                     worker:     userAccount
  101.                 }
  102.             }
  103.             ]
  104.         }).then(result => {
  105.                                 console.log(result);
  106.                                 alert("领取成功");
  107.                                 getTaskList();
  108.                           })
  109.           .catch(error => {console.error(error);alert("发生错误！" + error)});
  110.     });
  112.     //提交任务
  113.     $(".Commit").on("click", function() {
  114.         console.log("提交任务");
  115.         $("#SubmitTask").modal();
  116.         getTaskList();
  117.     });
  118.     //确认提交
  119.     $(".ConfirmSubmission").on("click", function() {
  121.         var TaskID  = $("#GetTaskID").val();
  122.         var TaskInfo = $("#TaskInformation").val();
  123.         console.log(TaskInfo);
  124.         $(".close_win").click();
  125.         eos.transaction({
  126.             actions: [
  127.                 {
  128.                     account: 'pdjtask',
  129.                     name:    'commit',
  130.                     authorization: [{
  131.                         actor:      userAccount,
  132.                         permission: 'active'
  133.                     }],
  135.                     data: {
  136.                         taskID:     TaskID,
  137.                         memo:       TaskInfo
  138.                     }
  139.                 }
  140.             ]
  141.         }).then(result => {     console.log(result);
  142.                                 alert("提交成功");
  143.                                 getTaskList();
  144.                           })
  145.           .catch(error => {console.error(error);alert("发生错误！" + error)});
  146.     }); 
  148.     //验收任务
  149.     $(".Confirm").on("click", function() {
  150.         console.log("验收任务");
  151.         $("#ConfirmTask").modal();
  152.         getTaskList();
  153.     });
  154.     //确认验收
  155.     $(".TaskConfirm").on("click", function() {
  157.         var TaskID  = $("#taskid").val();
  158.         var TaskStatus = $("#TaskStatus").val();
  159.         TaskStatus = parseInt(TaskStatus);
  160.         console.log(TaskID,TaskStatus);
  161.         $(".close_win").click();
  162.         eos.transaction({
  163.             actions: [
  164.                 {
  165.                     account: 'pdjtask',
  166.                     name:    'confirm',
  167.                     authorization: [{
  168.                         actor:      userAccount,
  169.                         permission: 'active'
  170.                     }],
  172.                     data: {
  173.                         taskID:     TaskID,
  174.                         ok:         TaskStatus
  175.                     }
  176.                 }
  177.             ]
  178.         }).then(result => {
  179.                              console.log(result);
  180.                              alert("任务验收成功");
  181.                              getTaskList();
  182.                              getBalance();
  183.                            })
  184.           .catch(error => {console.error(error);alert("发生错误！" + error)});
  186.     }); 
  188.     //查看余额
  189.     function getBalance(){
  190.         eos.getCurrencyBalance({
  191.             account: userAccount,
  192.             code: 'pdjtoken',
  193.             symbol: 'PTK'
  194.         })
  195.         .then(result => {   console.log(result);
  196.                             if(result.length == 0)
  197.                                 $(".balance span:nth-child(2)").html("余额：0");
  198.                             else
  199.                                 $(".balance span:nth-child(2)").html("余额：" + result);
  200.                         })
  201.         .catch(error => console.error(error));
  202.     }
  204.     //console.log(eos);
  206.     //任务列表
  207.     function getTaskList(){
  208.         eos.getTableRows({
  209.             scope:  'pdjtask',
  210.             code:   'pdjtask',
  211.             table:  'tasks',
  212.             json:   true,
  213.             lower_bound: 0,
  214.             upper_bound: -1,
  215.             limit:  20
  216.         })
  217.         .then(function(result){
  218.             console.log(result.rows);
  219.             var tr;
  220.             var tkStatus = "";
  221.             for(var i = 0; i < result.rows.length; i++){
  223.                 if(result.rows[i].status == 0)
  224.                     tkStatus = "未领取";
  225.                 else if(result.rows[i].status == 1)
  226.                     tkStatus = "已领取";
  227.                 else if(result.rows[i].status == 2)
  228.                     tkStatus = "已提交";
  229.                 else
  230.                     tkStatus = "已结束";
  232.                 tr += '<tr>';
  233.                 tr += '<td class="active">'+result.rows[i].taskID+'</td>';
  234.                 tr += '<td class="success">'+result.rows[i].creator+'</td>';
  235.                 tr += '<td class="warning">'+result.rows[i].worker+'</td>';
  236.                 tr += '<td class="danger">'+result.rows[i].bonus+'</td>';
  237.                 tr += '<td class="info">'+tkStatus+'</td>';
  238.                 tr += '<td class="active">'+result.rows[i].remark+'</td>';
  239.                 tr += '<td class="success">'+result.rows[i].comment+'</td>';
  240.                 tr += '</tr>';
  242.             }
  243.             //console.log(tr);
  244.             $("#list").html(tr);
  246.         })
  247.         .catch(error => console.error(error));
  248.     }
  250. });

  本文只包含部分核心代码，点击这里可获取全部代码和文件。以上就是本次分享的内容，欢迎大家学习交流。


EOS开发实战的更多相关文章

  1. EOS开发入门

    EOS开发入门   在上一篇文章<EOS开发环境搭建>中,我们已经完成了EOS开发环境的搭建,本次为大家带来的是EOS开发入门的相关内容. 1. EOS的合约开发基础   智能合约是一种旨 ...

  2. chrome拓展开发实战：页面脚本的拦截注入

    原文请访问个人博客:chrome拓展开发实战:页面脚本的拦截注入 目前公司产品的无线站点已经实现了业务平台组件化,所有业务组件的转场都是通过路由来完成,而各个模块是通过requirejs进行统一管理, ...

  3. 《Android NFC 开发实战详解 》简介+源码+样章+勘误ING

    <Android NFC 开发实战详解>简介+源码+样章+勘误ING SkySeraph Mar. 14th  2014 Email:skyseraph00@163.com 更多精彩请直接 ...

  4. CSS高效开发实战:CSS 3、LESS、SASS、Bootstrap、Foundation --读书笔记（1）设定背景图

    技术的新发展,除计算机可以接入互联网之外,平板电脑.智能手机.智能电视等其他设备均可访问互联网.在多设备时代,构建多屏体验也不是听说的那么难. 但是这也增加了学习CSS的难度?不知道如何上手,只懂一点 ...

  5. 《Node.js开发实战详解》学习笔记

    <Node.js开发实战详解>学习笔记 ——持续更新中 一.NodeJS设计模式 1 . 单例模式 顾名思义,单例就是保证一个类只有一个实例,实现的方法是,先判断实例是否存在,如果存在则直 ...

  6. 第九篇 ：微信公众平台开发实战Java版之如何实现自定义分享内容

    第一部分:微信JS-SDK介绍 微信JS-SDK是微信公众平台面向网页开发者提供的基于微信内的网页开发工具包. 通过使用微信JS-SDK,网页开发者可借助微信高效地使用拍照.选图.语音.位置等手机系统 ...

  7. 第八篇 ：微信公众平台开发实战Java版之如何网页授权获取用户基本信息

    第一部分:微信授权获取基本信息的介绍 我们首先来看看官方的文档怎么说: 如果用户在微信客户端中访问第三方网页,公众号可以通过微信网页授权机制,来获取用户基本信息,进而实现业务逻辑. 关于网页授权回调域 ...

  8. 第七篇 ：微信公众平台开发实战Java版之如何获取微信用户基本信息

    在关注者与公众号产生消息交互后,公众号可获得关注者的OpenID(加密后的微信号,每个用户对每个公众号的OpenID是唯一的.对于不同公众号,同一用户的openid不同). 公众号可通过本接口来根据O ...

  9. 第六篇 ：微信公众平台开发实战Java版之如何自定义微信公众号菜单

    我们来了解一下 自定义菜单创建接口: http请求方式:POST(请使用https协议) https://api.weixin.qq.com/cgi-bin/menu/create?access_to ...

随机推荐

  1. Linux启动Redis失败/没有那个文件或目录

    没有那个文件或目录问题,可能是你选择的目录不对. 应切换到Redis目录下启动.

  2. Python内置函数(15)——dict

    英文文档: class dict(**kwarg) class dict(mapping, **kwarg) class dict(iterable, **kwarg) Return a new di ...

  3. 有了这 4 大特性，CDN 好用到飞起

    随着 CDN 市场的快速发展和网络新技术的不断涌现,目前的 CDN 已不仅仅是当初简单的内容分发,同时也是新特性研发.新技术推广及实践的平台.这些新技术.新特性,或者能够保障 CDN 安全性,或是提升 ...

  4. TDX指标的理解与改造（价格到达指标线提醒）

    目的:画线指标理解,并同时改造成条件选股指标. 参考:https://mp.csdn.net/postedit/83176406 #ff7700 hex color  https://www.colo ...

  5. java基础(二)-----java的三大特性之继承

    在<Think in java>中有这样一句话:复用代码是Java众多引人注目的功能之一.但要想成为极具革命性的语言,仅仅能够复制代码并对加以改变是不够的,它还必须能够做更多的事情.在这句 ...

  6. asp.net core系列 33 EF查询数据 (2)

    一. 原生SQL查询 接着上篇讲.通过 Entity Framework Core 可以在使用关系数据库时下降到原始 SQL 查询. 在无法使用 LINQ 表达要执行的查询时,或因使用 LINQ 查询 ...

  7. C++中int与string的转化

    C++中int与string的转化 int本身也要用一串字符表示,前后没有双引号,告诉编译器把它当作一个数解释.缺省情况下,是当成10进制(dec)来解释,如果想用8进制,16进制,怎么办?加上前缀, ...

  8. [开发技巧]·TensorFlow中numpy与tensor数据相互转化

    [开发技巧]·TensorFlow中numpy与tensor数据相互转化 个人主页–> https://xiaosongshine.github.io/ - 问题描述 在我们使用TensorFl ...

  9. Linux 进程管理工具 supervisord 安装及使用

    Supervisor是用Python实现的一款非常实用的进程管理工具 1.安装过程非常简单 安装python 安装meld3-0.6.8.tar.gz 安装supervisor-3.0a12.tar. ...

  10. [51nod1355] 斐波那契的最小公倍数

    Description 给定 \(n\) 个正整数 \(a_1,a_2,...,a_n\),求 \(\text{lcm}(f_{a_1},f_{a_2},...,f_{a_n})\).其中 \(f_i ...