旺仔2488
旺仔2488

MT5入门到精通之十二（交易类）

2017/4/30
一.常用交易函数封装
1.6种挂单类型
1.1.limit是亏损方向
buy limit
sell limit

1.2.stop是盈利方向
buy stop
sell stop

1.3.buy stop limit 先突破盈利方向 在回调
sell stop limit
2.交易类实现

//+------------------------------------------------------------------+
//|                                                        Trade.mqh |
//|                        Copyright 2017, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2017, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class Trade
  {
private:

public:
   //slPoint = stop loss point止损点，tpPoint = take profit Point止盈点
   int               buy(string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);
   int               buyPlus(string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);
   //买入挂单
   int               buyPendingOrder(double pendingPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);
   int               buyPendingOrderPlus(double pendingPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);
   //买入stop limit
   int               buyPendingStoplimitOrder(double stopPrice,double limitPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);
   int               buyPendingStoplimitOrderPlus(double stopPrice,double limitPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);

   int               sell(string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);
   int               sellPlus(string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);
   //卖出挂单
   int               sellPendingOrder(double pendingPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);
   int               sellPendingOrderPlus(double pendingPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);
   //卖出stop limit
   int               sellPendingStoplimitOrder(double stopPrice,double limitPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);
   int               sellPendingStoplimitOrderPlus(double stopPrice,double limitPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic);

   void              closeAllBuy(string symbol,int magic=0);
   void              closeAllSell(string symbol,int magic=0);
   void              closeALLBuyAndSell(string symbol,int magic=0);
   void              mofiyStoplossAndTakeProfit(string symbol,ENUM_POSITION_TYPE type,double sl,double tp,int magic=0);
   //修改挂单止盈止损
   void              modifyPendingOrderStoplossAndTakeProfit(string symbol,ENUM_ORDER_TYPE type,double pendingPrice,double limitPrice,double sl,double tp,int magic=0);
   void              deleteAllPendingOrders(string symbol,int magic);

   //获取指定类型的持仓单数量
   int               getPositionNum(string symbol,ENUM_POSITION_TYPE type,int magic=0);
   int               getAllPositionNum(string symbol,int magic=0);

   //获取指定类型订单累计盈利总额
   double            profit(string symbol,ENUM_POSITION_TYPE type,int magic=0);
   //所有订单累计盈利总额
   double            profitall(string symbol,int magic=0);

   //获取格式化单量(平台允许的最接近单量)
   double            formatLots(string symbol,double lots);
   //下百分比的单量
   double            percentLots(ENUM_ORDER_TYPE action,string symbol,int percent);

   //获取最新的持仓单单号
   int               getNewestPositionOrder(string symbol,ENUM_POSITION_TYPE type,double &openprice,datetime &opentime,double &openlots,double &opensl,double &opentp,int magic=0);
   //盈亏平衡点（等于这个点位BEP，就刚好不赚不亏）   
   double            breakEvenPointPrice(string symbol,ENUM_POSITION_TYPE type,int magic=0);
   //移动止损(trailingPoint：移动点)
   void              trailingStop(int trailingPoint,string symbol,ENUM_POSITION_TYPE type,int magic=0);
   //获取最近的交易类型历史订单
   void              getLastDealsHistory(string symbol,ENUM_DEAL_TYPE type,double &deal_price,datetime &deal_time,double &lots,int magic=0);
   //当前货币对小数点位数
   int               digits(string symbol);
                     Trade();
                    ~Trade();
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Trade::Trade()
  {
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
Trade::~Trade()
  {
  }
//+------------------------------------------------------------------+
//slPoint = stop loss point止损点，tpPoint = take profit Point止盈点
int Trade::buy(string symbol,double lots,int slPoint,int tpPoint,string comment,int magic)
  {
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
//市价单
   request.action=TRADE_ACTION_DEAL;
   request.magic=magic;

   request.symbol=symbol;
   request.volume=lots;
   request.price=SymbolInfoDouble(symbol,SYMBOL_ASK);
   if(slPoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.sl=SymbolInfoDouble(symbol,SYMBOL_ASK)-slPoint*Point();
     }
   if(tpPoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.tp=SymbolInfoDouble(symbol,SYMBOL_ASK)+tpPoint*Point();
     }

//滑点
   request.deviation=100;
//多单
   request.type=ORDER_TYPE_BUY;

   request.comment=comment;

//--- 发送请求
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // 如果不能发送请求，输出错误代码
//--- 操作信息
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
   return(result.order);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Trade::buyPlus(string symbol,double lots,int slPoint,int tpPoint,string comment,int magic)
  {
   int a=0;
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY && PositionGetInteger(POSITION_MAGIC)==magic && PositionGetString(POSITION_COMMENT)==comment)
           {
            //不开单
            a=1;
            return(0);
           }
        }
     }
   if(a==0)
     {
      a=buy(symbol,lots,slPoint,tpPoint,comment,magic);
     }
   return(a);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Trade::buyPendingOrder(double pendingPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic)
  {
   pendingPrice=NormalizeDouble(pendingPrice,Digits());
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
   request.action=TRADE_ACTION_PENDING;
   request.magic=magic;

   request.symbol=symbol;
   request.volume=lots;
   request.price=pendingPrice;

   request.sl=pendingPrice-slPoint*Point();
   request.tp=pendingPrice+tpPoint*Point();

   request.deviation=100;

   double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);
   if(pendingPrice>ask)
     {
      request.type=ORDER_TYPE_BUY_STOP;
     }
   if(pendingPrice=0;i--)
     {
      if(OrderGetTicket(i)>0)
        {
         if(OrderGetString(ORDER_SYMBOL)==symbol && (OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_BUY_LIMIT || OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_BUY_STOP) && OrderGetInteger(ORDER_MAGIC)==magic && OrderGetString(ORDER_COMMENT)==comment)
           {
            a=1;
            return(0);
           }
        }
     }
   if(a==0)
     {
      a=buyPendingOrder(pendingPrice,symbol,lots,slPoint,tpPoint,comment,magic);
     }
   return(a);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Trade::buyPendingStoplimitOrder(double stopPrice,double limitPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic)
  {
   stopPrice=NormalizeDouble(stopPrice,Digits());
   limitPrice=NormalizeDouble(limitPrice,Digits());
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
   request.action=TRADE_ACTION_PENDING;
   request.type=ORDER_TYPE_BUY_STOP_LIMIT;
   request.symbol=symbol;
   double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);
   if(stopPrice<=ask)
     {
      Alert("stopPrice必须大于市价");
      return(0);
     }
   if(limitPrice>=stopPrice)
     {
      Alert("limitprice必须小于stopprice");
      return(0);
     }
   request.volume=lots;
   request.deviation=100;
   request.price=stopPrice;
   request.stoplimit=limitPrice;
   if(slPoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.sl=limitPrice-slPoint*Point();
     }
   if(tpPoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.tp=limitPrice+tpPoint*Point();
     }

   request.comment=comment;
   request.magic=magic;
//--- 发送请求
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // 如果不能发送请求，输出错误代码
   return(result.order);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Trade::buyPendingStoplimitOrderPlus(double stopPrice,double limitPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic)
  {
   int a=0;
   int t=OrdersTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(OrderGetTicket(i)>0)
        {
         if(OrderGetString(ORDER_SYMBOL)==symbol && (OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_BUY_STOP_LIMIT) && OrderGetInteger(ORDER_MAGIC)==magic && OrderGetString(ORDER_COMMENT)==comment)
           {
            //不开挂单
            a=1;
            return(0);
           }
        }
     }
   if(a==0)
     {
      a=buyPendingStoplimitOrder(stopPrice,limitPrice,symbol,lots,slPoint,tpPoint,comment,magic);
     }
   return(a);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Trade::sell(string symbol,double lots,int slPoint,int tpPoint,string comment,int magic)
  {
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
//市价单
   request.action=TRADE_ACTION_DEAL;
   request.magic=magic;

   request.symbol=symbol;
   request.volume=lots;
   request.price=SymbolInfoDouble(symbol,SYMBOL_BID);
   if(slPoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.sl=SymbolInfoDouble(symbol,SYMBOL_BID)+slPoint*Point();
     }
   if(tpPoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.tp=SymbolInfoDouble(symbol,SYMBOL_BID)-tpPoint*Point();
     }

//滑点
   request.deviation=100;
//空单
   request.type=ORDER_TYPE_SELL;

   request.comment=comment;

//--- 发送请求
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // 如果不能发送请求，输出错误代码
//--- 操作信息
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
   return(result.order);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Trade::sellPlus(string symbol,double lots,int slPoint,int tpPoint,string comment,int magic)
  {
   int a=0;
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL && PositionGetInteger(POSITION_MAGIC)==magic && PositionGetString(POSITION_COMMENT)==comment)
           {
            //不开单
            a=1;
            return(0);
           }
        }
     }
   if(a==0)
     {
      a=sell(symbol,lots,slPoint,tpPoint,comment,magic);
     }
   return(a);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Trade::sellPendingOrder(double pendingPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic)
  {
   pendingPrice=NormalizeDouble(pendingPrice,Digits());
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
//市价单
   request.action=TRADE_ACTION_PENDING;
   request.magic=magic;

   request.symbol=symbol;
   request.volume=lots;
   request.price=pendingPrice;

   request.sl=pendingPrice+slPoint*Point();
   request.tp=pendingPrice-tpPoint*Point();
//滑点
   request.deviation=100;
//空单
   double bid=SymbolInfoDouble(symbol,SYMBOL_BID);
   if(pendingPricebid)
     {
      request.type=ORDER_TYPE_SELL_LIMIT;
     }

   request.comment=comment;

//--- 发送请求
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // 如果不能发送请求，输出错误代码
   return(result.order);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Trade::sellPendingOrderPlus(double pendingPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic)
  {
   int a=0;
   int t=OrdersTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(OrderGetTicket(i)>0)
        {
         if(OrderGetString(ORDER_SYMBOL)==symbol && (OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_SELL_LIMIT || OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_SELL_STOP) && OrderGetInteger(ORDER_MAGIC)==magic && OrderGetString(ORDER_COMMENT)==comment)
           {
            //不开挂单
            a=1;
            return(0);
           }
        }
     }
   if(a==0)
     {
      a=sellPendingOrder(pendingPrice,symbol,lots,slPoint,tpPoint,comment,magic);
     }
   return(a);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Trade::sellPendingStoplimitOrder(double stopPrice,double limitPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic)
  {
   stopPrice=NormalizeDouble(stopPrice,Digits());
   limitPrice=NormalizeDouble(limitPrice,Digits());
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};

   request.action=TRADE_ACTION_PENDING;
   request.type=ORDER_TYPE_SELL_STOP_LIMIT;
   request.symbol=symbol;
   double bid=SymbolInfoDouble(symbol,SYMBOL_BID);
   if(stopPrice>=bid)
     {
      Alert("stopPrice必须小于市价");
      return(0);
     }
   if(limitPrice<=stopPrice)
     {
      Alert("limitprice必须大于stopprice");
      return(0);
     }
   request.volume=lots;
//滑点
   request.deviation=100;
   request.price=stopPrice;
   request.stoplimit=limitPrice;
   if(slPoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.sl=limitPrice+slPoint*Point();
     }
   if(tpPoint>SymbolInfoInteger(symbol,SYMBOL_TRADE_STOPS_LEVEL))
     {
      request.tp=limitPrice-tpPoint*Point();
     }

   request.comment=comment;
   request.magic=magic;

//--- 发送请求
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // 如果不能发送请求，输出错误代码
   return(result.order);

  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int Trade::sellPendingStoplimitOrderPlus(double stopPrice,double limitPrice,string symbol,double lots,int slPoint,int tpPoint,string comment,int magic)
  {
   int a=0;
   int t=OrdersTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(OrderGetTicket(i)>0)
        {
         if(OrderGetString(ORDER_SYMBOL)==symbol && (OrderGetInteger(ORDER_TYPE)==ORDER_TYPE_SELL_STOP_LIMIT) && OrderGetInteger(ORDER_MAGIC)==magic && OrderGetString(ORDER_COMMENT)==comment)
           {
            //不开挂单
            a=1;
            return(0);
           }
        }
     }
   if(a==0)
     {
      a=sellPendingStoplimitOrder(stopPrice,limitPrice,symbol,lots,slPoint,tpPoint,comment,magic);
     }
   return(a);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trade::closeAllBuy(string symbol,int magic=0)
  {
//持仓单遍历
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      //选择持仓单
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
           {
            bool needClose=false;
            if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
              {
               needClose=true;
              }

            if(needClose)
              {
               MqlTradeRequest request={0};
               MqlTradeResult  result={0};
               request.action=TRADE_ACTION_DEAL;                     // 交易操作类型
               request.symbol=symbol;                              // 交易品种
               request.volume=PositionGetDouble(POSITION_VOLUME); //交易量 
               request.type=ORDER_TYPE_SELL;                        //订单类型
               request.price=SymbolInfoDouble(symbol,SYMBOL_BID); // 持仓价格                                                   
               request.deviation=100;//滑点
               request.position=PositionGetTicket(i);//平仓最好都写下，不然和sell一样了。
               if(!OrderSend(request,result))
                  PrintFormat("OrderSend error %d",GetLastError());   // 如果不能发送请求，输出错误

              }

           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trade::closeAllSell(string symbol,int magic=0)
  {
//持仓单遍历
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      //选择持仓单
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
           {
            bool needClose=false;
            if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
              {
               needClose=true;
              }
            if(needClose)
              {
               MqlTradeRequest request={0};
               MqlTradeResult  result={0};
               request.action=TRADE_ACTION_DEAL;                     // 交易操作类型
               request.symbol=symbol;                              // 交易品种
               request.volume=PositionGetDouble(POSITION_VOLUME); // 交易量 
               request.type=ORDER_TYPE_BUY;                        // 订单类型
               request.price=SymbolInfoDouble(symbol,SYMBOL_ASK); // 持仓价格
               request.deviation=100; //滑点
               request.position =PositionGetTicket(i);
               if(!OrderSend(request,result))
                  PrintFormat("OrderSend error %d",GetLastError());   // 如果不能发送请求，输出错误

              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trade::closeALLBuyAndSell(string symbol,int magic=0)
  {
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
           {
            bool needClose=false;
            if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
              {
               needClose=true;
              }
            if(needClose)
              {
               MqlTradeRequest request={0};
               MqlTradeResult  result={0};
               request.action=TRADE_ACTION_DEAL;                     // 交易操作类型
               request.symbol=symbol;                              // 交易品种
               request.volume=PositionGetDouble(POSITION_VOLUME); // 交易量 
               request.type=ORDER_TYPE_SELL;                        // 订单类型
               request.price=SymbolInfoDouble(symbol,SYMBOL_BID); // 持仓价格
               request.deviation=100; //滑点
               request.position =PositionGetTicket(i);
               if(!OrderSend(request,result))
                  PrintFormat("OrderSend error %d",GetLastError());   // 如果不能发送请求，输出错误

              }
           }
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
           {
            bool needClose=false;
            if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
              {
               needClose=true;
              }
            if(needClose)
              {
               MqlTradeRequest request={0};
               MqlTradeResult  result={0};
               request.action=TRADE_ACTION_DEAL;                     // 交易操作类型
               request.symbol=symbol;                              // 交易品种
               request.volume=PositionGetDouble(POSITION_VOLUME); // 交易量 
               request.type=ORDER_TYPE_BUY;                        // 订单类型
               request.price=SymbolInfoDouble(symbol,SYMBOL_ASK); // 持仓价格
               request.deviation=100; //滑点
               request.position =PositionGetTicket(i);
               if(!OrderSend(request,result))
                  PrintFormat("OrderSend error %d",GetLastError());   // 如果不能发送请求，输出错误

              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//修改止盈止损
void Trade::mofiyStoplossAndTakeProfit(string symbol,ENUM_POSITION_TYPE type,double sl,double tp,int magic=0)
  {
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol)
           {
            double old_sl=NormalizeDouble(PositionGetDouble(POSITION_SL),digits(symbol));
            double old_tp=NormalizeDouble(PositionGetDouble(POSITION_TP),digits(symbol));
            double new_sl=NormalizeDouble(sl,digits(symbol));
            double new_tp=NormalizeDouble(sl,digits(symbol));

            //PrintFormat("buysell:old_sl=%lf,old_tp=%lf,new_sl=%lf,new_tp=%lf",old_sl,old_tp,new_sl,new_tp);
            if(type==POSITION_TYPE_BUY)
              {
               bool needAction=false;
               if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
                 {
                  needAction=true;
                 }
               if(needAction)
                 {
                  MqlTradeRequest request={0};
                  MqlTradeResult  result={0};
                  //Modify Stop Loss and Take Profit values of an opened position
                  request.action=TRADE_ACTION_SLTP;
                  // Position ticket 
                  request.position=PositionGetTicket(i);
                  request.symbol=symbol;

                  if(sl>0 && new_sl!=old_sl) request.sl=new_sl;
                  if(tp>0 && new_tp!=old_tp) request.tp=new_tp;

                  if(!OrderSend(request,result))
                     PrintFormat("OrderSend error %d",GetLastError());

                 }
              }
            if(type==POSITION_TYPE_SELL)
              {
               bool needAction=false;
               if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
                 {
                  needAction=true;
                 }
               if(needAction)
                 {
                  MqlTradeRequest request={0};
                  MqlTradeResult  result={0};
                  request.action=TRADE_ACTION_SLTP;
                  request.position=PositionGetTicket(i);
                  request.symbol=symbol;

                  if(sl>0 && new_sl!=old_sl) request.sl=new_sl;
                  if(tp>0 && new_tp!=old_tp) request.tp=new_tp;

                  if(!OrderSend(request,result))
                     PrintFormat("OrderSend error %d",GetLastError());
                 }

              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trade::modifyPendingOrderStoplossAndTakeProfit(string symbol,ENUM_ORDER_TYPE type,double pendingPrice,double limitPrice,double sl,double tp,int magic=0)
  {
   int t=OrdersTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(OrderGetTicket(i)>0)
        {
         if(OrderGetString(ORDER_SYMBOL)==symbol)
           {
            //1.stop 和 limit类型
            if(type==ORDER_TYPE_BUY_LIMIT || type==ORDER_TYPE_BUY_STOP || type==ORDER_TYPE_SELL_LIMIT || type==ORDER_TYPE_SELL_STOP)
              {
               bool needAction=false;
               if(magic==0 || OrderGetInteger(ORDER_MAGIC)==magic)
                 {
                  needAction=true;
                 }
               if(needAction)
                 {
                  MqlTradeRequest request={0};
                  MqlTradeResult  result={0};
                  //Modify Stop Loss and Take Profit values of an opened position
                  request.action=TRADE_ACTION_MODIFY;
                  request.type=type;
                  // Position ticket 
                  request.order=OrderGetTicket(i);
                  request.symbol=symbol;
                  if(sl>0)request.sl=NormalizeDouble(sl,digits(symbol));
                  if(tp>0)request.tp=NormalizeDouble(tp,digits(symbol));

                  if(pendingPrice!=0)
                    {
                     request.price=NormalizeDouble(pendingPrice,Digits());
                    }
                  if(sl<0) request.sl=NormalizeDouble(OrderGetDouble(ORDER_SL),digits(symbol));
                  if(tp<0) request.tp=NormalizeDouble(OrderGetDouble(ORDER_TP),digits(symbol));

                  if(!OrderSend(request,result))
                     PrintFormat("OrderSend error %d",GetLastError());

                 }
              }
            //2.stoplimit类型
            if(type==ORDER_TYPE_BUY_STOP_LIMIT || type==ORDER_TYPE_SELL_STOP_LIMIT)
              {
               bool needAction=false;
               if(magic==0 || OrderGetInteger(ORDER_MAGIC)==magic)
                 {
                  needAction=true;
                 }
               if(needAction)
                 {
                  MqlTradeRequest request={0};
                  MqlTradeResult  result={0};
                  //Modify Stop Loss and Take Profit values of an opened position
                  request.action=TRADE_ACTION_MODIFY;
                  request.type=type;
                  // Position ticket 
                  request.order=OrderGetTicket(i);
                  request.symbol=symbol;
                  if(sl>0)request.sl=NormalizeDouble(sl,digits(symbol));
                  if(tp>0)request.tp=NormalizeDouble(tp,digits(symbol));

                  if(pendingPrice!=0)
                    {
                     request.price=NormalizeDouble(pendingPrice,Digits());
                    }
                  if(limitPrice!=0)
                    {
                     request.stoplimit=NormalizeDouble(limitPrice,Digits());
                    }

                  if(sl<0) request.sl=NormalizeDouble(OrderGetDouble(ORDER_SL),digits(symbol));
                  if(tp<0) request.tp=NormalizeDouble(OrderGetDouble(ORDER_TP),digits(symbol));

                  if(!OrderSend(request,result))
                     PrintFormat("OrderSend error %d",GetLastError());

                 }

              }
           }
        }
     }
  }
//删除所有挂单
void Trade::deleteAllPendingOrders(string symbol,int magic)
  {
   int t=OrdersTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(OrderGetTicket(i)>0)
        {
         if(OrderGetString(ORDER_SYMBOL)==symbol)
           {
            bool needAction=false;
            if(magic==0 || OrderGetInteger(ORDER_MAGIC)==magic)
              {
               needAction=true;
              }
            if(needAction)
              {
               MqlTradeRequest request={0};
               MqlTradeResult  result={0};
               //Delete the pending order placed previously
               request.action=TRADE_ACTION_REMOVE;
               request.order=OrderGetTicket(i);
               request.symbol=symbol;
               if(!OrderSend(request,result))
                  PrintFormat("OrderSend error %d",GetLastError());
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
int Trade::getPositionNum(string symbol,ENUM_POSITION_TYPE type,int magic=0)
  {
   int a=0;
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==type)
           {
            bool needAction=false;
            if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
              {
               needAction=true;
              }
            if(needAction)
              {
               a++;
              }
           }
        }
     }
   return(a);
  }
//+------------------------------------------------------------------+
int Trade::getAllPositionNum(string symbol,int magic=0)
  {
   int a=0;
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY || PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL))
           {
            bool needAction=false;
            if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
              {
               needAction=true;
              }
            if(needAction)
              {
               a++;
              }
           }
        }
     }
   return(a);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double Trade::profit(string symbol,ENUM_POSITION_TYPE type,int magic=0)
  {
   double a=0;
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==type)
           {
            bool needAction=false;
            if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
              {
               needAction=true;
              }
            if(needAction)
              {
               a=a+PositionGetDouble(POSITION_PROFIT)+PositionGetDouble(POSITION_SWAP);
              }
           }
        }
     }
   return(a);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double Trade::profitall(string symbol,int magic=0)
  {
   double a=0;
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && (PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY || PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL))
           {

            bool needAction=false;
            if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
              {
               needAction=true;
              }
            if(needAction)
              {
               a=a+PositionGetDouble(POSITION_PROFIT)+PositionGetDouble(POSITION_SWAP);
              }
           }
        }
     }
   return(a);
  }
//+------------------------------------------------------------------+
double Trade::formatLots(string symbol,double lots)
  {
   double a=0;
   double miniLots=SymbolInfoDouble(symbol,SYMBOL_VOLUME_MIN);
   double stepLots=SymbolInfoDouble(symbol,SYMBOL_VOLUME_STEP);
   if(lots=0;i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==type)
           {
            bool needAction=false;
            if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
              {
               needAction=true;
              }
            if(needAction)
              {
               openPrice=PositionGetDouble(POSITION_PRICE_OPEN);
               openTime=PositionGetInteger(POSITION_TIME);
               openLots=PositionGetDouble(POSITION_VOLUME);
               openStopLoss=PositionGetDouble(POSITION_SL);
               openTakeProfit=PositionGetDouble(POSITION_TP);
               ticket=PositionGetInteger(POSITION_TICKET);
               break;
              }
           }
        }
     }
   return(ticket);
  }
//+------------------------------------------------------------------+
double Trade::breakEvenPointPrice(string symbol,ENUM_POSITION_TYPE type,int magic=0)
  {
   double a=0;
   double totalLots=0;
   double sum=0;
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol && PositionGetInteger(POSITION_TYPE)==type)
           {
            bool needAction=false;
            if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
              {
               needAction=true;
              }
            if(needAction)
              {
               if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
                 {
                  totalLots=totalLots+PositionGetDouble(POSITION_VOLUME);
                  sum=sum+PositionGetDouble(POSITION_VOLUME)*PositionGetDouble(POSITION_PRICE_OPEN);
                 }
               if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
                 {
                  totalLots=totalLots-PositionGetDouble(POSITION_VOLUME);
                  sum=sum-PositionGetDouble(POSITION_VOLUME)*PositionGetDouble(POSITION_PRICE_OPEN);
                 }
              }

           }
        }
     }
   if((totalLots!=0) && (sum!=0))
     {
      a=NormalizeDouble(sum/totalLots,SymbolInfoInteger(symbol,SYMBOL_DIGITS));
     }
   else
     {
      a=0;
     }
   return(a);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trade::trailingStop(int trailingPoint,string symbol,ENUM_POSITION_TYPE type,int magic=0)
  {
   int t=PositionsTotal();
   for(int i=t-1;i>=0;i--)
     {
      if(PositionGetTicket(i)>0)
        {
         if(PositionGetString(POSITION_SYMBOL)==symbol)
           {
            double bid=SymbolInfoDouble(symbol,SYMBOL_BID);
            double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);
            double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
            double openPrice=PositionGetDouble(POSITION_PRICE_OPEN);
            double sl=PositionGetDouble(POSITION_SL);
            double tp=PositionGetDouble(POSITION_TP);
            if(type==POSITION_TYPE_BUY)
              {
               if((bid-openPrice)>=point*trailingPoint && (sl<(bid-point*trailingPoint) || (sl==0)))
                 {
                  bool needAction=false;
                  if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
                    {
                     needAction=true;
                    }
                  if(needAction)
                    {
                     MqlTradeRequest request={0};
                     MqlTradeResult  result={0};
                     request.action=TRADE_ACTION_SLTP;
                     request.position=PositionGetTicket(i);
                     request.symbol=symbol;
                     request.sl=bid-point*trailingPoint;
                     request.tp=tp;
                     if(!OrderSend(request,result))
                        PrintFormat("OrderSend error %d",GetLastError());
                    }
                 }
              }
            if(type==POSITION_TYPE_SELL)
              {
               if((openPrice-ask)>=point*trailingPoint && ((sl>(ask+point*trailingPoint)) || (sl==0)))
                 {
                  bool needAction=false;
                  if(magic==0 || PositionGetInteger(POSITION_MAGIC)==magic)
                    {
                     needAction=true;
                    }
                  if(needAction)
                    {
                     MqlTradeRequest request={0};
                     MqlTradeResult  result={0};
                     request.action=TRADE_ACTION_SLTP;
                     request.position=PositionGetTicket(i);
                     request.symbol=symbol;
                     request.sl=ask+point*trailingPoint;
                     request.tp=tp;
                     if(!OrderSend(request,result))
                        PrintFormat("OrderSend error %d",GetLastError());
                    }
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trade::getLastDealsHistory(string symbol,ENUM_DEAL_TYPE type,double &deal_price,datetime &deal_time,double &lots,int magic=0)
  {
  //1.一般都要写这个
   HistorySelect(0,TimeCurrent());
   int dealsTotal=HistoryDealsTotal();
   for(int i=dealsTotal-1;i>=0;i--)
     {
      int deal_ticket=HistoryDealGetTicket(i);
      if(deal_ticket>0)
        {
         if(HistoryDealGetInteger(deal_ticket,DEAL_ENTRY)==DEAL_ENTRY_OUT && HistoryDealGetString(deal_ticket,DEAL_SYMBOL)==symbol && HistoryDealGetInteger(deal_ticket,DEAL_TYPE)==type)
           {
            if(magic==0)
              {
               deal_time=HistoryDealGetInteger(deal_ticket,DEAL_TIME);
               lots=HistoryDealGetDouble(deal_ticket,DEAL_VOLUME);
               deal_price=HistoryDealGetDouble(deal_ticket,DEAL_PRICE);
               break;
              }
            else
              {
               if(HistoryDealGetInteger(deal_ticket,DEAL_MAGIC)==magic)
                 {
                  deal_time=HistoryDealGetInteger(deal_ticket,DEAL_TIME);
                  lots=HistoryDealGetDouble(deal_ticket,DEAL_VOLUME);
                  deal_price=HistoryDealGetDouble(deal_ticket,DEAL_PRICE);
                  break;
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
int Trade::digits(string symbol)
  {
   return SymbolInfoInteger(symbol,SYMBOL_DIGITS);
  }
//+------------------------------------------------------------------+

2.1.交易类使用

//+------------------------------------------------------------------+
//|                                              commonUseScript.mq5 |
//|                        Copyright 2017, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2017, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"

//显示确认框
#property script_show_confirm
#include 

int magic=170430;
Trade td;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   //td.buy(Symbol(),0.1,200,200,"buy",magic);
//td.sell(Symbol(),0.1,200,200,"sell",magic);
//td.closeAllBuy(Symbol());
//td.closeAllSell(Symbol());
//td.closeALLBuyAndSell(Symbol());
//td.mofiyStoplossAndTakeProfit(Symbol(),POSITION_TYPE_BUY,1.00,1.19);
//td.deleteAllPendingOrders(Symbol());
//double lots=td.formatLots(Symbol(),1.23456);
   double openPrice=0;
   datetime openTime=0;
   double openLots=0;
   double openStopLoss=0;
   double openTakeProfit=0;
   int ticket=td.getNewestPositionOrder(Symbol(),POSITION_TYPE_SELL,openPrice,openTime,openLots,openStopLoss,openTakeProfit);
  }
//+------------------------------------------------------------------+

如果您发现本文对你有所帮助，如果您认为其他人也可能受益，请把它分享出去。

你可能感兴趣的:(MT5入门到精通之十二（交易类）)

  • 美易官方：盘前道指期货涨0.5%，游戏驿站跌逾15% 美股投资 财经人工智能大数据新浪微博微信微信公众平台百度金融
    在股市开盘前的交易时段，道指期货上涨了0.5%，而游戏驿站（GameStop）的股价却出现了大幅下跌，跌幅超过15%。这一市场动态引发了投资者的广泛关注，也反映了当前股市的复杂性和不确定性。美股股指期货周三盘前走强，交易员为季度末的再平衡做准备。本周因假期而缩短，美国将公布关键通胀数据。道指期货涨0.5%，标普500指数期货涨0.6%，纳指期货涨0.5%。德国DAX指数涨0.4%，英国富时100指
  • 《昼颜》里的日本女人：相遇要万种风情，分手要残忍绝情 迷影咖啡
    作者：迷之菌子神奇菇迷影咖啡：一本正经做烘焙，胡说八道聊电影漫天萤火虫消散之时良宵就将过去，人们也说含苞待放的花蕾总会开了又谢，因紧紧相拥而面红耳赤的躯体，便是我们经历过这热爱的证明。夫妻关系介绍《昼颜》是2014年电视剧《昼颜：工作日下午三点的恋人们》的续集，故事发在电视剧情节结束的三年后，讲述了已经恢复独身的纱和偶然与曾经的出轨对象北野重逢后再次陷入感情漩涡的故事。《昼颜》制作灵感源自利佳子在
  • 迎接2019 唯有杜康1994
    告别2018这一年是机遇与挑战，痛苦与喜悦，失去与收获的一年一月:收获了第一份爱情，开始真正想去了解一个人三月:对工作有了更深入的认识，靠自己的力量完成晋升五月:搬家，住进了自己理想的公寓，一间属于自己的屋子。满地的书六月:外调广州，升经理，有了自己的第一个团队。七月:怀着自我否定，第一次完成了部门任务八月:第一个员工流失，痛哭不已明白无不散之筵席九月:员工陆续离开，经济是一切的根本。十月:陪员工
  • 亲子日记之祝姑姥姥生日快乐（282） 冰心雨露_d504
    2021年7月18日，周日，晴周日上班的不上班，上学的不上学，全家都属于休息状态，洗衣做饭是上午的主要任务，中午休息一会儿，下午比较晚了出去给梦怡买了二年级上册的口算题卡，然后去参加姑姑的生日聚餐，本来姑姑应该是周一生日，因为周一都要上班，就提前到周日过了，说是过生日其实就是想借此机会一家人聚聚，毕竟平常都忙，没有时间聚在一起，梦怡还给姑姥姥做了生日贺卡，虽然长相一般，重在心意。生日快乐
  • android 自定义曲线图,Android自定义View——贝赛尔曲线 weixin_39767513 android自定义曲线图
    个人博客：haichenyi.com。感谢关注本文针对有一定自定义View的童鞋，最好对贝赛尔曲线有辣么一丢丢了解，不了解也没关系。花5分钟看一下GcsSloop的安卓自定义View进阶-Path之贝塞尔曲线。本文的最终效果图：最终效果图.gif思路首先他是一个只有上半部分的正弦形状的水波纹，很规则。其次，他这个正弦图左右在移动。然后，就是它这个自定义View，上下也在移动，是慢慢增加的最后，优化
  • 信任 饮冰伊乔
    随着社会的发展，微信和支付宝交易给人们带来了极大的方便，越来越多的人出门都只选择拿一部手机即可，方便安全，可昨天我就遇到了一件比较尴尬的事。昨天傍晚，我从公司出来，感觉有点饿，决定索性吃了饭再回去，来到去过几次的一个店里，如往常一样叫了餐，当时店里吃饭的不多，老板麻利的先去做了，正要扫微信付账的时候发现手机没电了，迷之尴尬，我只好跟老板说不用做了，手机没电了，我身上又没现金，付不了帐了。老板娘很热
  • 花气袭人知昼暖 柒侠传
    花气袭人知昼暖高一七班黄韵熹37号花袭人，原名花珍珠，位列金陵十二钗又副册中的第二位。“袭人”这一称呼源于“花气袭人知昼暖”这一诗句，是宝玉给起的。想起来便觉得暖融融的，一如花袭人温柔的笑容。但花袭人着实是令人又爱又怕的角色。第二十一回的回目将她赞作“贤袭人”，脂砚斋在一旁批道“当得起”。花袭人对宝玉的确是一片真心。她为劝宝玉收敛他那成日在大观园里与姐姐妹妹“厮混”的性子，假借家人赎回的机会，软语
  • SpringMVC设置全局异常处理器 水岸齐天 javaspring
    文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
  • 细水长流的日子之二百五十二（一点一点慢慢长大） 独一无二的小茶叶
    2021-10-22今天小妹妹刚来，见到放在桌篓子里晾着的薰青豆，想要吃，给她拿个小碗装了点，我正在厨房收拾，嘱咐她自己去坐在小椅子上吃，她却一屁股坐在厨房门口的地板上吃起来不小心打翻了，就直接趴在地板上一粒一粒地捡拾。口渴了，自己去把奶瓶里剩下的奶喝掉，然后到厨房门口将奶瓶提给我让我洗干净，把手伸的很长，边小嘴巴里说哇哇，我不让她的小脚跨进厨房半步，怕自己有时没看好出现意外，她牢牢记着，脚绝对不
  • Django之Debug篇 菜鸟之编程 Djangodjangopython后端
    一、DebugToolBar基本使用1.1、概述Django框架的调试工具栏使用django-debug-toolbar库，是一组可配置的面板，显示有关当前请求/响应的各种调试信息，点击时，显示有关面板内容的更多详细信息。官方文档：DjangoDebugToolbar—DjangoDebugToolbar4.3.0documentation1.2、安装pipinstalldjango-debug-
  • 以高质量调查研究助力组织工作提质增效 木同木同
    近日，中共中央办公厅印发了《关于在全党大兴调查研究的工作方案》(后简称《方案》），要求各地区各部门结合实际认真贯彻落实。调查研究是我们党的传家宝，是谋事之基、成事之道。组织部门作为党管干部的核心部门，肩负着管党员、管干部、管人才的重要职责，调查研究更是把握组织工作规律、破解组织工作难题的重要办法。要用好调查研究这一法宝，把准政治方向，贯穿问题导向，坚持实事求是，以高质量调查研究助力组织工作提质增效
  • 地低为海人低为王 缘梦草
    地低为海，人低为王。低，高之基，高，低之顶。谦虚才能收益，咄咄逼人会招损。高粱熟了，头会低下。受益反而会深藏不露。捧人之术，把人捧高，然后控制。受控之人，大都是虚荣心作祟。活成别人想象中的样子，像别人想象中那么有面子的活着是悲哀的。穷不可怕，怕的是虚荣心。当你好面子，你就会被控制。一旦受虚荣心控制，你不得不谨小慎微的维护面子，付出多余的能量，希望得到别人的一句赞。面子就是金子打造的牢笼，让你在赞美
  • C#WPF窗口类 Window详解 未来无限 C#WPF程序设计c#wpfwindow类详解
    本文详解C#WPF窗口类Window。目录定义Window窗体属性Window窗体事件实例演示定义WPF中的Window继承于ContentControl，内部可以承载一个Content，当然，借助于ItemsControl或Panel，Content也可以向下添加多个
  • 计划比盲目做重要 一祉微笑
    坚持分享第99天。一次次会议提醒着老师们假期余额不足，马上面临停机状态。50多天掐指而过，想想放假时的计划，对照如今的完成情况，感觉差太远。想着好好看书，如今50多天过去了第6本还处在未完待续状态；想着假期好好陪陪孩子，在玩中学一些知识，如今想想，孩子学的真不多；想着暑假坚持跑步，有时还是容易给自己找借口，休息三两天。给这个假期一个综合评价，只能说只完成了计划的百分之五六十。想想为什么临近开学没达
  • 081天 约柜失而复得 宁宁2018
    撒迦利亚书4:6他对我说：“这是耶和华指示所罗巴伯的。万军之耶和华说：‘不是倚靠势力，不是倚靠才能，乃是倚靠我的灵方能成事。’
  • 《金文成〈正蒙〉日记124。2020-11-9》 金吾生
    《金文成〈正蒙〉日记124。2020-11-9》今天是庚子丁亥丙子，九月廿四，2020年11月9日星期一。作者篇7【舜之孝，汤、武之武，虽顺逆不同，其为不幸均矣。】船山讲解说，顺，指的是舜的父亲最终受到感化，转变了态度，结局圆满之事；逆，指的是＂桀放、纣诛＂，即，商汤放桀，周武诛纣，都是采用暴力，不是感化方式，所以是逆。顺与逆，都是为了解决弊政，然其差异之大如此，然而，无论圆满还是遗憾，其实他们都
  • 第一次用eclipse,导入项目错误Plug-in “org.eclipse.m2e.editor“ was unable to instantiate MavenPomEditor zhangfeng1133 eclipsejavaide
    第一次用eclipse,导入项目错误Plug-in"org.eclipse.m2e.editor"wasunabletoinstantiateMavenPomEditor。各种项目包，都不存在，maven应该能自动载入类包，比Php的composer方便太多Thecontainer'MavenDependencies'referencesnonexistinglibrary'C:\Users\Ad
  • SQLite版本3中的文件锁定和并发(七） 代码工匠云 数据库SQLiteC与c++sqlitec++数据库
    返回：SQLite—系列文章目录上一篇：自己编译SQLite或将SQLite移植到新的操作系统（六）下一篇：SQLite—系列文章目录正文：1.0SQLite版本3中的文件锁定和并发SQLite版本3.0.0引入了新的锁定和日志功能旨在提高SQLite版本2的并发性的机制并减少作家的饥饿问题。新机制还允许交易的原子提交涉及多个数据库文件。本文档介绍新的锁定机制。目标受众是想要理解和/或修改的程序员
  • 如何把大象装进冰箱的思考 210624 大丁_初心生活
    央视春晚曾有个小品，宋丹丹问赵本山，如何把大象装进冰箱。赵本山说不知道。宋丹丹得意地说，第一步，把冰箱门打开。第二步，把大象装进去。第三步，把冰箱门关上。我相信很多人看了都是一笑了之，我们也从潜意识上给出了否定的答案。樊登老师给出了不一样的解读，他认为这其实是解决问题的经典方法。“把大象装冰箱”，目标十分明确，宋丹丹给出的执行步骤也十分清晰。可赵本山却不会？难道赵本山不知道这三个步骤吗？肯定知道。
  • 27.Python从入门到精通—Python异常处理 抛出异常 用户自定义异常 定义清理行为 预定义的清理行为 以山河作礼。 #Python基础入门—详解版pythonjava服务器
    27.从入门到精通：Python异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理抛出异常用户自定义异常定义清理行为预定义的清理行为异常处理在Python中，异常处理是一种处理程序在执行期间可能遇到的错误的方法。当Python解释器遇到错误时，它会引发异常。异常是一种Python对象，它包含有关错误的信息，例如错误类型和错误位置。为了处理异常，您可以使用try-except语句。在
  • [高精度加法和乘法] 阶乘之和 StudyingPanda 算法
    题目描述用高精度计算出S=1!+2!+3!+⋯+n!（n≤50）。其中!表示阶乘，定义为n!=n×(n−1)×(n−2)×⋯×1。例如，5!=5×4×3×2×1=120。输入格式一个正整数n。输出格式一个正整数S，表示计算结果。输入输出样例输入#13输出#19解题分析思路很简单，求出阶乘之后再累次求和即可，但是关键在于这个数据量实在是太大了，所以必须封装高精度运算，这里我们创建一个BigInt类，
  • VGG16滤镜可视化和类激活图 LIjin_1006 人工智能神经网络深度学习cnn
    这个用keras2.2.4+tensorflow1.15.0importkeraskeras.__version__fromkeras.applicationsimportVGG16fromkerasimportbackendasKimportnumpyasnpfromkerasimportmodelsimportmatplotlib.pyplotaspltimporttensorflowastf
  • Python | Redis工具类 -拟墨画扇- Pythonredis数据库缓存python
    一、需求自动连接Redis数据库，通过连接池处理数据对输出结果进行Log打印并保存到文件二、代码Utils.redisUtils.py#!/usr/bin/envpython#-*-coding:utf-8-*-importredisfromUtils.loggerimportlog"""Redis数据格式(1)字符串|存储形式:key-value:str-存储二进制数据:可以存储任意类型的数据，
  • 谈教育 浅辙
    也许，现在很多人都认为教育是无可避免的一个话题，而且意义深远。然而，究其缘由无非是希望孩子有个好的将来，所以使其奔波与于各个补习班之间，像是被提起的棋子，该落到何处便落到何处！不是吗？那情形，不过是大人的一厢情愿！也许只是鄙人的愚见，毕竟是单身狗，可能没有过多的发言权，不过以我个人的看法，何苦让孩子们如此曲折，这样痛苦的不只是孩子还有自己，文化艺术类的倒是有必要让孩子去学一下，学业课程已有了系统的
  • 道德经第三十四章 套马地汉纸
    道德经第三十四章原文：大道泛兮，其可左右！万物恃之而生，而不辞，功成不名有。爱养万物而不为主，常无欲，可名于小；万物归焉而不为主，可名为大。是以圣人终不为大，故能成其大。译文：大道广泛流行，无所不到。万物依赖它生长而不推辞，有所成就而不自以为有功。养育万物而不自以为主，永远没有私欲，可以说是渺小得很，所以可称它为“小”；物归附于它而它不自以为主宰，可以说极其伟大，所以可称它为“大”。由于它不自以为
  • Linux学习系列之vim编辑器（一） llibertyll linux学习
    vi编辑器的操作模式输入模式—aio等—>命令模式<—：键—末行模式从输入/末行模式切换到命令模式都是需要按ESC键注:a光标后输入，i光标前输入，o直接向下加一行输入，O向上加一行输入在vi编辑器中光标的移动（命令行模式下）键组合（命令）光标的移动$光标移动到当前行的结尾0（零）光标移动到当前行的开始GG光标移动到最后一行gg光标移动到第一行在命令行模式下删除与复制的操作键组合（命令）含义dd删
  • 6/21 最后的编织之观后感 ChereAlicia
    今天看了7分钟震撼人心之短篇有种当局者迷旁观者清的感觉在外人眼里看来已经足够但自有人深陷其中无法自拔而那个人很有可能是自己超脱物质寻求自己真正想要的方能得到内心的平息和安宁图片发自App
  • 每天学点成语 余子烨
    1、口诀：功败垂成未成功，不以为然不赞同；火中取栗被利用，罚不当罪处罚重；2、解释：功败垂成：事情接近成功的时候却遭到了失败。出自：《三国志·杨阜传》：“弃垂成之功，陷不义之名，阜以死守之。”不以为然：不认为是对的。表示不同意或否定。出自：宋·苏轼《再乞罢详定役法状》：“右臣先曾奏论前衙一役，只当招募，不当定差，执政不以为然。”火中取栗：一只猴子和一只猫看见炉火中烤着栗子，猴子叫猫去偷，猫用爪子从
  • 2023-11-07 碎碎念念的每一天
    忽然开始自卑了，感觉自己无论各个方面都太平平，读书不多，家务做不好，体重控制的不好，早起也困难，起来又不知道该做什么，没有一个可以为之奋斗的目标，也没有很好的交际圈，感觉自己就像一只在笼子里的鸟，想飞也飞不高……我想改变这样的现状，可该如何呢？其实都是我不够努力，没有争分夺秒，没有自律，这些都是我未来跟人拉开差距的原因，所以，我不应该只是自卑，自卑过头会变成焦虑，我应该努力去改变，哪怕改变一小点，
  • 富格林：重视平台挑选阻挠虚假 fgl100 金融
    富格林悉知，在金融市场中，现货黄金一直被视为避险资产和投资保值的选择之一，吸引了众多投资者的关注。越来越多投资者也开始重视交易平台的挑选，毕竟虚假平台对我们的交易百害无一利。因此，我们要学会阻挠虚假平台选择正规可信平台。下面富格林将给大家总结一些阻挠虚假平台的挑选细则。注意平台的口碑评价是否优质。现货黄金交易市场巨大，平台数量众多，平台质量参差不齐，因此要挑选出优质平台，投资者需要了解平台的口碑评
  • jdk tomcat 环境变量配置 Array_06 javajdktomcat
    Win7 下如何配置java环境变量 1。准备jdk包，win7系统，tomcat安装包（均上网下载即可） 2。进行对jdk的安装，尽量为默认路径（但要记住啊！！以防以后配置用。。。） 3。分别配置高级环境变量。   电脑-->右击属性-->高级环境变量-->环境变量。 分别配置 : path    &nbs
  • Spring调SDK包报java.lang.NoSuchFieldError错误 bijian1013 javaspring
            在工作中调另一个系统的SDK包，出现如下java.lang.NoSuchFieldError错误。 org.springframework.web.util.NestedServletException: Handler processing failed; nested exception is java.l
  • LeetCode[位运算] - #136 数组中的单一数 Cwind java题解位运算LeetCodeAlgorithm
    原题链接：#136 Single Number 要求： 给定一个整型数组，其中除了一个元素之外，每个元素都出现两次。找出这个元素 注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间 难度：中等 分析： 题目限定了线性的时间复杂度，同时不使用额外的空间，即要求只遍历数组一遍得出结果。由于异或运算 n XOR n = 0, n XOR 0 = n，故将数组中的每个元素进
  • qq登陆界面开发 15700786134 qq
    今天我们来开发一个qq登陆界面，首先写一个界面程序，一个界面首先是一个Frame对象，即是一个窗体。然后在这个窗体上放置其他组件。代码如下： public class First {         public void initul(){        jf=ne
  • Linux的程序包管理器RPM 被触发 linux
    在早期我们使用源代码的方式来安装软件时，都需要先把源程序代码编译成可执行的二进制安装程序，然后进行安装。这就意味着每次安装软件都需要经过预处理-->编译-->汇编-->链接-->生成安装文件--> 安装，这个复杂而艰辛的过程。为简化安装步骤，便于广大用户的安装部署程序，程序提供商就在特定的系统上面编译好相关程序的安装文件并进行打包，提供给大家下载，我们只需要根据自己的
  • socket通信遇到EOFException 肆无忌惮_ EOFException
    java.io.EOFException at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2281) at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:
  • 基于spring的web项目定时操作 知了ing javaWeb
    废话不多说，直接上代码，很简单 配置一下项目启动就行 1，web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="h
  • 树形结构的数据库表Schema设计 矮蛋蛋 schema
    原文地址： http://blog.csdn.net/MONKEY_D_MENG/article/details/6647488     程序设计过程中，我们常常用树形结构来表征某些数据的关联关系，如企业上下级部门、栏目结构、商品分类等等，通常而言，这些树状结构需要借助于数据库完成持久化。然而目前的各种基于关系的数据库，都是以二维表的形式记录存储数据信息，
  • maven将jar包和源码一起打包到本地仓库 alleni123 maven
    http://stackoverflow.com/questions/4031987/how-to-upload-sources-to-local-maven-repository <project> ... <build> <plugins> <plugin> <groupI
  • java IO操作 与 File 获取文件或文件夹的大小，可读，等属性！！！ 百合不是茶
    类 File File是指文件和目录路径名的抽象表示形式。 1，何为文件： 标准文件（txt doc mp3...） 目录文件（文件夹） 虚拟内存文件   2，File类中有可以创建文件的 createNewFile（）方法,在创建新文件的时候需要try{} catch(）{}因为可能会抛出异常；也有可以判断文件是否是一个标准文件的方法isFile();这些防抖都
  • Spring注入有继承关系的类（2） bijian1013 javaspring
    被注入类的父类有相应的属性，Spring可以直接注入相应的属性，如下所例：1.AClass类 package com.bijian.spring.test4; public class AClass { private String a; private String b; public String getA() { retu
  • 30岁转型期你能否成为成功人士 bijian1013 成长励志
            很多人由于年轻时走了弯路，到了30岁一事无成，这样的例子大有人在。但同样也有一些人，整个职业生涯都发展得很优秀，到了30岁已经成为职场的精英阶层。由于做猎头的原因，我们接触很多30岁左右的经理人，发现他们在职业发展道路上往往有很多致命的问题。在30岁之前，他们的职业生涯表现很优秀，但从30岁到40岁这一段，很多人
  • 【Velocity四】Velocity与Java互操作 bit1129 velocity
    Velocity出现的目的用于简化基于MVC的web应用开发，用于替代JSP标签技术，那么Velocity如何访问Java代码.本篇继续以Velocity三http://bit1129.iteye.com/blog/2106142中的例子为基础，      POJO    package com.tom.servlets; public
  • 【Hive十一】Hive数据倾斜优化 bit1129 hive
    什么是Hive数据倾斜问题   操作：join,group by,count distinct 现象：任务进度长时间维持在99%（或100%），查看任务监控页面，发现只有少量（1个或几个）reduce子任务未完成；查看未完成的子任务，可以看到本地读写数据量积累非常大，通常超过10GB可以认定为发生数据倾斜。 原因：key分布不均匀 倾斜度衡量：平均记录数超过50w且
  • 在nginx中集成lua脚本：添加自定义Http头，封IP等 ronin47 nginx lua csrf
    Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。 强制搜索引擎只索引mixlr.com Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 location /{
  • java-3.求子数组的最大和 bylijinnan java
    package beautyOfCoding; public class MaxSubArraySum { /** * 3.求子数组的最大和 题目描述： 输入一个整形数组，数组里有正数也有负数。 数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。 求所有子数组的和的最大值。要求时间复杂度为O(n)。 例如输入的数组为1, -2, 3, 10, -4,
  • Netty源码学习-FileRegion bylijinnan javanetty
    今天看org.jboss.netty.example.http.file.HttpStaticFileServerHandler.java 可以直接往channel里面写入一个FileRegion对象，而不需要相应的encoder： //pipeline（没有诸如“FileRegionEncoder”的handler）： public ChannelPipeline ge
  • 使用ZeroClipboard解决跨浏览器复制到剪贴板的问题 cngolon 跨浏览器复制到粘贴板Zero Clipboard
    Zero Clipboard的实现原理 Zero Clipboard 利用透明的Flash让其漂浮在复制按钮之上，这样其实点击的不是按钮而是 Flash ，这样将需要的内容传入Flash，再通过Flash的复制功能把传入的内容复制到剪贴板。 Zero Clipboard的安装方法 首先需要下载 Zero Clipboard的压缩包，解压后把文件夹中两个文件：ZeroClipboard.js
  • 单例模式 cuishikuan 单例模式
    第一种（懒汉，线程不安全）： public class Singleton {   2     private static Singleton instance;   3     pri
  • spring+websocket的使用 dalan_123
    一、spring配置文件 <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"    xmlns:xsi="http://www.w3.or
  • 细节问题：ZEROFILL的用法范围。 dcj3sjt126com mysql
    1、zerofill把月份中的一位数字比如1，2，3等加前导0 mysql> CREATE TABLE t1 (year YEAR(4), month INT(2) UNSIGNED ZEROFILL,    -> day
  • Android开发10——Activity的跳转与传值 dcj3sjt126com Android开发
    Activity跳转与传值，主要是通过Intent类，Intent的作用是激活组件和附带数据。   一、Activity跳转 方法一Intent intent = new Intent(A.this, B.class); startActivity(intent)   方法二Intent intent = new Intent();intent.setCla
  • jdbc 得到表结构、主键 eksliang jdbc 得到表结构、主键
    转自博客：http://blog.csdn.net/ocean1010/article/details/7266042 假设有个con DatabaseMetaData dbmd = con.getMetaData(); rs = dbmd.getColumns(con.getCatalog(), schema, tableName, null); rs.getSt
  • Android 应用程序开关GPS gqdy365 android
    要在应用程序中操作GPS开关需要权限： <uses-permission android:name="android.permission.WRITE_SECURE_SETTINGS" /> 但在配置文件中添加此权限之后会报错，无法再eclipse里面正常编译，怎么办？ 1、方法一：将项目放到Android源码中编译； 2、方法二：网上有人说cl
  • Windows上调试MapReduce zhiquanliu mapreduce
    1.下载hadoop2x-eclipse-plugin https://github.com/winghc/hadoop2x-eclipse-plugin.git 把 hadoop2.6.0-eclipse-plugin.jar 放到eclipse plugin 目录中。 2.下载 hadoop2.6_x64_.zip http://dl.iteye.com/topics/download/d2b
  • 如何看待一些知名博客推广软文的行为？ justjavac 博客
    本文来自我在知乎上的一个回答：http://www.zhihu.com/question/23431810/answer/24588621 互联网上的两种典型心态： 当初求种像条狗，如今撸完嫌人丑 当初搜贴像条犬，如今读完嫌人软 你为啥感觉不舒服呢？ 难道非得要作者把自己的劳动成果免费给你用，你才舒服？ 就如同 Google 关闭了 Gooled Reader，那是
  • sql优化总结 macroli sql
    为了是自己对sql优化有更好的原则性，在这里做一下总结，个人原则如有不对请多多指教。谢谢！   要知道一个简单的sql语句执行效率，就要有查看方式，一遍更好的进行优化。   一、简单的统计语句执行时间 declare @d datetime ---定义一个datetime的变量set @d=getdate() ---获取查询语句开始前的时间select user_id
  • Linux Oracle中常遇到的一些问题及命令总结 超声波 oraclelinux
    1.linux更改主机名   (1)#hostname oracledb　　　　临时修改主机名 (2) vi /etc/sysconfig/network 　　修改hostname (3) vi /etc/hosts　　　　　　　　修改IP对应的主机名   2.linux重启oracle实例及监听的各种方法 （注意操作的顺序应该是先监听，后数据库实例） &nbs
  • hive函数大全及使用示例 superlxw1234 hadoophive函数
      具体说明及示例参 见附件文档。     文档目录：   目录 一、关系运算： 4 1. 等值比较: = 4 2. 不等值比较: <> 4 3. 小于比较: < 4 4. 小于等于比较: <= 4 5. 大于比较: > 5 6. 大于等于比较: >= 5 7. 空值判断: IS NULL 5
  • Spring 4.2新特性-使用@Order调整配置类加载顺序 wiselyman spring 4
    4.1 @Order Spring 4.2 利用@Order控制配置类的加载顺序 4.2 演示 两个演示bean package com.wisely.spring4_2.order; public class Demo1Service { } package com.wisely.spring4_2.order; public class
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他