É uma coisa muito divertida escrever estratégias durante a semana, e todas as ideias de jogos de azar aparecem no editor, talvez seja o seu próximo jogo de cartas, o que é emocionante! A única coisa que afeta essa paixão é o processamento da lógica de compra e venda do sistema de estratégia de negociação, que é essencial para o processamento desse módulo de negociação, mas é um pouco chato e a lógica é mais complexa.
- Não. Interval Intervalo de reatendimento falhado (millisec) Tipo numérico (numero) 500 SlideTick Número de pontos de preço deslizante (inteiro) Tipo numérico (número) 1 RiskControl Ativar controle de vento Bol (true/false) Falso MaxTrade@RiskControl Número máximo de transações por dia numérico (numero) 50 MaxTradeAmount@RiskControl Número máximo de assinaturas por moeda (número) 1000 */
var __orderCount = 0 // Regista o próximo número de unidades do dia de trabalho atual var __orderDay = 0 // Regista a data do dia de trabalho atual
função CanTrade ((tradeAmount) { // Modulo de controle de risco, Parâmetros: Número de transações
if (!RiskControl) { // Não ativar o módulo de controle de vento por padrão, se não for ativado, a função CanTrade retornará true
Retorno verdadeiro
Não.
if (typeof ((tradeAmount) ==
função init ((() { // função de inicialização do modelo, que é executada primeiro quando o modelo é carregado.
if (typeof ((SlideTick) ===
função GetPosition ((e, contractType, direction, positions) { // Combina um contrato com posições anteriores e atuais na mesma direção, com os parâmetros: Objeto da bolsa, tipo de contrato, direção, dados de posicionamento devolvidos pela API ((vazio)
var allCost = 0; // contractType Contrato na direção do total do dinheiro gasto, sem multiplicar o número de pontos de um contrato ((porque o total pode ser combinado)
var allAmount = 0; // Número total de assinantes
var allProfit = 0; // ganhos e prejuízos somados
var allFrozen = 0; // Número total de congelamento
var pos Margin = 0; // Contratos de detenção Alavancagem
if (typeof(positions) ===
função Open ((e, contractType, direction, opAmount) { // Operação de um contrato de variedade única Função de abertura de negociação, parâmetros: objeto da bolsa, código do contrato, direção, número de operações
var initPosition = GetPosition ((e, contractType, direction); // a função GetPosition é chamada no topo para obter informações de armazenamento após a combinação.
var isFirst = true; // Marca de configuração isFirst (indica que o seguinte while é o primeiro ciclo verdadeiro)
var initAmount = initPosition? initPosition.Amount : 0; // Se o initPosition for null, o initAmount será atribuído a 0, caso contrário, o initPosition.Amount será atribuído
var positionNow = initPosition; // declara que uma variável positionNow indica a informação de armazenamento atual
while (true) { // while loop
var needOpen = opAmount; // declara a variável temporária needOpen e atribui-lhe um valor com o parâmetro quantidade de transações necessárias
if (isFirst) { // Se for a primeira vez executada, apenas atualize o bloco isFirst. Marcado como falso, o próximo ciclo executará o bloco else.
isFirst = falso;
} else {
positionNow = GetPosition ((e, contractType, direction); // atualizar positionNow, a informação de armazenamento atual.
if (positionNow) { // Se houver informações sobre o posicionamento, o número de posições necessárias para abrir a próxima needOpen é igual ao número de operações exigidas pelo parâmetro menos a diferença entre as informações sobre o posicionamento obtidas nesta vez e a última (ou seja, quantas novas mãos foram abertas)
needOpen = opAmount - (positionNow.Amount - initAmount);
Não.
Não.
var insDetail = _C ((e. SetContractType, contractType); // Configure o tipo de contrato.
// Log (para o arquivo inicial, initAmount, para o arquivo atual, positionNow, para o arquivo necessário, needOpen);
if (needOpen < insDetail.MinLimitOrderVolume) { // Se o próximo número de posições a serem abertas for menor do que o número mínimo de posições abertas da lista de limites do contrato
break; // sair do ciclo
Não.
if (!CanTrade(opAmount)) { // Modulo de controle de vento Detecta, se retornar false Saia do ciclo sem negociar.
O que é o que você está fazendo?
Não.
Var depth = _C ((e.GetDepth); // obtém informações sobre a profundidade do mercado.
var amount = Math.min ((insDetail.MaxLimitOrderVolume, needOpen); // Limite a quantidade de encomendas não pode ser maior do que a quantidade máxima de encomendas do limite de preços do contrato
e.SetDirection ((direction == PD_LONG?
Função Cover ((e, contractType) { // Função de liquidação de variedade única, parâmetros: objeto de troca, código de contrato
var insDetail = _C ((e.SetContractType, contractType); // Configure o tipo de contrato
while (true) { // ciclo principal while
var n = 0; // Contagem de operações de estacionamento
var opAmount = 0; // declaração Operação Variavel
var positions = _C ((e.GetPosition); // Invoca a API para obter informações de armazenamento, distinguindo a função de armazenamento acima. Veja a documentação da API para mais detalhes.
for (var i = 0; i < positions.length; i++) { // percorrer Informações de armazenamento
se (positions[i].ContractType!= contractType) { // Se a informação de armazenamento do índice atual não é igual ao contrato a operar, ou seja: contractType
Continue; // Salte
Não.
var amount = Math.min ((insDetail.MaxLimitOrderVolume, positions[i].Amount); // Controla o volume máximo de transações não superior a um recibo
var depth;
if (positions[i].Type == PD_LONG の の positions[i].Type == PD_LONG_YD) { // Processar múltiplos postos
depth = _C(e.GetDepth); // Chama a API para obter dados atuais do disco
opAmount = Math.min ((amount, depth.Bids[0].Amount); // restrição
if (!CanTrade ((opAmount)) { // Detecção do módulo de controle de vento
return (em inglês);
Não.
e.SetDirection ((positions[i].Type == PD_LONG?
e.Sell(depth.Bids[0].Price - (insDetail.PriceTick * SlideTick), opAmount, contractType, positions[i].Type == PD_LONG ? "平今" : "平昨", 'Bid', depth.Bids[0]);
// 执行平仓 API ，详细参见 API文档。
n++; // 操作计数累加
} else if (positions[i].Type == PD_SHORT || positions[i].Type == PD_SHORT_YD) { // 处理 空仓 类似多仓处理
depth = _C(e.GetDepth);
opAmount = Math.min(amount, depth.Asks[0].Amount);
if (!CanTrade(opAmount)) {
return;
}
e.SetDirection(positions[i].Type == PD_SHORT ? "closesell_today" : "closesell");
e.Buy(depth.Asks[0].Price + (insDetail.PriceTick * SlideTick), opAmount, contractType, positions[i].Type == PD_SHORT ? "平今" : "平昨", 'Ask', depth.Asks[0]);
n++;
}
}
if (n === 0) { // 如果n 等于 0 ，即初始为0 ，在遍历时没有累加，没有可平的仓位。
break; // 跳出主while循环
}
while (true) { // 间隔一定时间后， 取消所有挂单。类似Open函数的 CancelPendingOrders
Sleep(Interval);
var orders = _C(e.GetOrders);
if (orders.length === 0) {
break;
}
for (var j = 0; j < orders.length; j++) {
e.CancelOrder(orders[j].Id);
if (j < (orders.length - 1)) {
Sleep(Interval);
}
}
}
}
}
var trans = { // Usado para exibir informações detalhadas da conta na barra de status, tradução para chinês, dicionário O Twitter é o site mais popular do mundo, com mais de 100 mil usuários. O que você pode fazer com o dinheiro que você tem disponível? O Banco Mundial (BMI) é o principal banco de dados do mundo, com cerca de US$ 1 bilhão de depósitos em moeda estrangeira. A empresa de corretores de corretas é conhecida como "BrokerID", que é um código de corretor de corretas. A diferença de dinheiro cresceu, mas o número de pessoas que recebem dinheiro cresceu. O que é que ele está a fazer aqui? O presidente da Câmara de Freguesia de Vila Nova de Famalicão, José Manuel da Costa, disse que a decisão da Câmara foi tomada por unanimidade. O que é que ele está a fazer aqui? O Curr Margin Curr: Curr, o valor total da garantia atual é currido, mas o valor total da garantia é currido. O Bitcoin é uma moeda digital criada para ser usada em todo o mundo. O que é o que você está fazendo agora? O banco de depósitos: depõe uma quantia de ouro no banco, e o banco de depósitos, em vez de depender do valor do depósito, paga o valor do depósito. O Bitcoin é o maior mercado de valores de todos os tempos, e o maior mercado de valores de todos os tempos. O Bitcoin é o maior mercado de valores do mundo, com mais de US$ 1 bilhão de dólares disponíveis. O que é o que você está fazendo com o seu dinheiro? A Comissão de Congelamento (FrozenCommission): Congelamento das taxas de serviço, congelamento das taxas de serviço, congelamento das taxas de serviço. O "Frozen Margin" é uma camada de ouro congelada que garante a segurança do consumidor. O FundMortgageAvailable está disponível para pagar o saldo da hipoteca. O que é o que você está fazendo agora? O FundMortgageOut é uma ferramenta de pagamento de depósitos de hipotecas que permite que o cliente pague uma quantia em dinheiro. A taxa de juros é muito alta, mas a taxa de juros é muito baixa. O Banco de Interesses (InterestBase): O Banco de Interesses (InterestBase) é um banco de dados de base de juros. O que é que isso significa para o Brasil? O Banco de Portugal é o único banco que tem o poder de garantir o financiamento de uma dívida pública. A posição de lucro é a posição de lucro da posição de lucro. A última vez que a Pre-Balance pagou a reserva de ouro, a Pre-Balance pagou R$ 5 milhões, o que representa R$ 5 milhões. A última vez que o meu crédito subiu, o meu crédito subiu. O pre-depósito é o limite de depósito da última vez que você fez um depósito. A última vez que o PreFundMortgageIn foi colocado no mercado, o valor foi reduzido para R$ 5 milhões. A última vez que o PreFundMortgageOut foi emitido, a quantia foi reduzida para R$ 5 bilhões. A Pre-Margin é um banco de valores de ouro que foi usado pela última vez por uma empresa de seguros. A última hipoteca que ele pagou foi uma hipoteca de R$ 1 milhão. O óleo de alumínio é um óleo essencial para a produção de óleo de alumínio. O Banco Central Europeu (BCE) é o principal banco central dos Estados Unidos. O que é o que você está fazendo agora? O produto especial ganha lucro e perde lucro, o produto especial ganha lucro e perde lucro. A Comissão de Produtos Específicos (SpecCommission) é responsável pela elaboração e execução dos pedidos de produtos específicos. O Bitcoin é o principal instrumento de troca de dinheiro entre os países do mundo, e é o principal instrumento de troca de dinheiro entre os países do mundo. O molho SpecProductFrozenCommission é um molho especial para congelamento de produtos. O molho SpecProductFrozenMargin é um molho de molho especial que é congelado com molho de ouro garantido. O óleo de alumínio é um óleo de alumínio de alta qualidade, que é usado para a fabricação de óleo de alumínio. O produto específico está em posição de lucro, o produto específico está em posição de lucro e o produto específico está em posição de lucro. O produto específico posicionado em lucro por alg: o produto específico posicionado em lucro por alg é calculado com base no algoritmo de lucro e prejuízo de posicionamento. O blog oficial do grupo, publicado no blog oficial da empresa, é o seguinte: O "Withdraw" é uma forma de tirar dinheiro do banco. O que você pode fazer com o seu dinheiro é retirar o seu dinheiro com o seu dinheiro. O que você está fazendo?
função AccountToTable ((jsStr, title) { // função para exportar informações de conta para um formulário de barra de status, parâmetros: cadeia de estruturas JSON a ser exibida, título
if (typeof(title) ===
var PositionManager = (function() { // Declara que uma variável PositionManager aceita o valor de retorno de uma função anônima, que retorna o valor de um objeto construído
function PositionManager ((e) { // declara que uma função PositionManager está dentro de uma função anônima.
if (typeof(e) ===
PositionManager.prototype.GetPosition = function(contractType, direction, positions) { // 给 PositionManager 添加方法 用于在主策略中调用该模板的 函数
return GetPosition(this.e, contractType, direction, positions);
};
PositionManager.prototype.OpenLong = function(contractType, shares) { // 添加 开多仓 方法
if (!this.account) {
this.account = _C(this.e.GetAccount);
}
return Open(this.e, contractType, PD_LONG, shares);
};
PositionManager.prototype.OpenShort = function(contractType, shares) { // 添加 开空仓 方法
if (!this.account) {
this.account = _C(this.e.GetAccount);
}
return Open(this.e, contractType, PD_SHORT, shares);
};
PositionManager.prototype.Cover = function(contractType) { // 添加 平仓 方法
if (!this.account) {
this.account = _C(this.e.GetAccount);
}
return Cover(this.e, contractType);
};
PositionManager.prototype.CoverAll = function() { // 添加 所有仓位全平方法
if (!this.account) {
this.account = _C(this.e.GetAccount);
}
while (true) {
var positions = _C(this.e.GetPosition)
if (positions.length == 0) {
break
}
for (var i = 0; i < positions.length; i++) { // 首先平掉 对冲合约 对冲合约 举例 MA709&MA705
// Cover Hedge Position First
if (positions[i].ContractType.indexOf('&') != -1) {
Cover(this.e, positions[i].ContractType)
Sleep(1000)
}
}
for (var i = 0; i < positions.length; i++) {
if (positions[i].ContractType.indexOf('&') == -1) {
Cover(this.e, positions[i].ContractType)
Sleep(1000)
}
}
}
};
PositionManager.prototype.Profit = function(contractType) { // 添加计算收益的方法
var accountNow = _C(this.e.GetAccount);
return _N(accountNow.Balance - this.account.Balance);
};
return PositionManager; // 匿名函数返回 在自身内声明的 PositionManager 函数（对象）。
})();
$.NewPositionManager = function(e) { // Exporta funções para construir um objeto PositionManager return new PositionManager ((e); O que você está fazendo?
// Via:http://mt.sohu.com/20160429/n446860150.shtml$.IsTrading = function ((symbol) { // Determina se um contrato está em negociação Num período de tempo, o parâmetro symbol Código do contrato var now = new Date ((); // Obter o objeto de tempo atual var day = now.getDay ((); // obtém o tempo atual em um dia específico da semana. var hour = now.getHours(); // obtém a hora de 24 horas var minute = now.getMinutes ((); // obtém o minuto em um minuto
if (day === 0 || (day === 6 && (hour > 2 || hour == 2 && minute > 30))) { // 第一个过滤， day == 0 星期天 或者 day == 6 星期六并且
return false; // 2点30以后 。 星期五 夜盘结束。 返回 false 即所有品种不在交易时间
}
symbol = symbol.replace('SPD ', '').replace('SP ', ''); // 正则表达式 匹配其交易系统用“SPD”表示跨期套利交易,若指令买进“SPD CF1609&CF17...
// 过滤掉 跨期套利的 合约编码
var p, i, shortName = "";
for (i = 0; i < symbol.length; i++) { // 遍历合约代码字符串，取出 代码（排除数字的部分）赋值给shortName 并且转换为大写
var ch = symbol.charCodeAt(i);
if (ch >= 48 && ch <= 57) {
break;
}
shortName += symbol[i].toUpperCase();
}
var period = [ // 通常交易时间 9：00 - 10：15，
[9, 0, 10, 15], // 10：30 - 11：30
[10, 30, 11, 30], // 13：30 - 15：00
[13, 30, 15, 0]
];
if (shortName === "IH" || shortName === "IF" || shortName === "IC") { // 如果是这些 品种，交易时间 period 调整
period = [
[9, 30, 11, 30],
[13, 0, 15, 0]
];
} else if (shortName === "TF" || shortName === "T") { // 国债品种 时间调整
period = [
[9, 15, 11, 30],
[13, 0, 15, 15]
];
}
if (day >= 1 && day <= 5) { // 如果是 周一 到周五， 不考虑夜盘。 判断当前时间是否符合 period 设定的时间表
for (i = 0; i < period.length; i++) {
p = period[i];
if ((hour > p[0] || (hour == p[0] && minute >= p[1])) && (hour < p[2] || (hour == p[2] && minute < p[3]))) {
return true; // 符合遍历出的 时间表 中的 时间段， 即该品种在交易时间内。
}
}
}
var nperiod = [ // 额外判断 夜盘品种 nperiod[n][0] 是夜盘时间相同的一类
// 品种汇总，nperiod[n][1] 就是该类品种的夜盘交易时间
[
['AU', 'AG'],
[21, 0, 02, 30]
],
[
['CU', 'AL', 'ZN', 'PB', 'SN', 'NI'],
[21, 0, 01, 0]
],
[
['RU', 'RB', 'HC', 'BU'],
[21, 0, 23, 0]
],
[
['P', 'J', 'M', 'Y', 'A', 'B', 'JM', 'I'],
[21, 0, 23, 30]
],
[
['SR', 'CF', 'RM', 'MA', 'TA', 'ZC', 'FG', 'IO'],
[21, 0, 23, 30]
],
];
for (i = 0; i < nperiod.length; i++) { // 遍历所有夜盘品种 交易时间段，对比当前时间。
for (var j = 0; j < nperiod[i][0].length; j++) {
if (nperiod[i][0][j] === shortName) {
p = nperiod[i][1];
var condA = hour > p[0] || (hour == p[0] && minute >= p[1]);
var condB = hour < p[2] || (hour == p[2] && minute < p[3]);
// in one day
if (p[2] >= p[0]) {
if ((day >= 1 && day <= 5) && condA && condB) {
return true;
}
} else {
if (((day >= 1 && day <= 5) && condA) || ((day >= 2 && day <= 6) && condB)) {
return true;
}
}
return false;
}
}
}
return false;
};
$.NewTaskQueue = function ((onTaskFinish) { // Função de construção de objetos de fila para transações de várias variedades. Parâmetros: função de retorno quando a tarefa é concluída. var self = {} // declara um objeto vazio self.ERR_SUCCESS = 0 // definição Retorna a mensagem Sucesso self.ERR_SET_SYMBOL = 1 // erro de configuração do contrato self.ERR_GET_RECORDS = 2 // Obter erro na linha K self.ERR_GET_ORDERS = 3 // Obtém erro de ordem não concluída self.ERR_GET_POS = 4 // Erro em obter informações de armazenamento self.ERR_TRADE = 5 // erro de transação self.ERR_GET_DEPTH = 6 // Obter erro de campo de profundidade self.ERR_NOT_TRADING = 7 // Não está no momento da negociação self.ERR_BUSY = 8 // Bloqueio
self.onTaskFinish = typeof(onTaskFinish) === 'undefined' ? null : onTaskFinish // 如果在 初始化队列对象时没有 传入需要回调的匿名函数，该属性赋值为null，否则赋值回调函数
self.retryInterval = 300 // 重试间隔 毫秒数
self.tasks = [] // 这个是一个重要的属性，队列中储存任务的数组。
self.pushTask = function(e, symbol, action, amount, arg, onFinish) { // 给空对象添加函数，该函数是压入 新任务 到任务数组中。参数分别为：
// 交易所对象、合约代码、执行动作、数量、回调函数参数、回调函数
var task = { // 构造一个任务对象
e: e, // 交易所对象
action: action, // 执行的动作
symbol: symbol, // 合约代码
amount: amount, // 操作数量
init: false, // 是否初始化
finished: false, // 是否任务完成
dealAmount: 0, // 已处理的 量
preAmount: 0, // 上一次的 量
preCost: 0, // 上一次的 花费
retry: 0, // 重试次数
maxRetry: 10, // 最大重试次数
arg: typeof(onFinish) !== 'undefined' ? arg : undefined, // 如果没有传入 回调函数，此项 设置为 undefined
onFinish: typeof(onFinish) == 'undefined' ? arg : onFinish // 如果没有传入回调函数，把 arg 复制给 onFinish（实际上是 arg没传入，中间隔过去了）
}
switch (task.action) { // 根据执行的动作初始化描述信息
case "buy":
task.desc = task.symbol + " 开多仓, 数量 " + task.amount
break
case "sell":
task.desc = task.symbol + " 开空仓, 数量 " + task.amount
break
case "closebuy":
task.desc = task.symbol + " 平多仓, 数量 " + task.amount
break
case "closesell":
task.desc = task.symbol + " 平空仓, 数量 " + task.amount
break
default:
task.desc = task.symbol + " " + task.action + ", 数量 " + task.amount
}
self.tasks.push(task) // 压入任务数组中
Log("接收到任务", task.desc) // 输出日志 显示 接收到任务。
}
self.cancelAll = function(e) { // 添加函数，取消所有，参数： 交易所对象
while (true) { // 遍历未完成的所有订单，逐个取消。
var orders = e.GetOrders();
if (!orders) { // 所有API 调用都不重试，如果API调用失败，立即返回。
return self.ERR_GET_ORDERS;
}
if (orders.length == 0) {
break;
}
for (var i = 0; i < orders.length; i++) {
e.CancelOrder(orders[i].Id);
Sleep(self.retryInterval);
}
}
return self.ERR_SUCCESS // 返回 完成标记
}
self.pollTask = function(task) { // 执行数组中弹出的任务
var insDetail = task.e.SetContractType(task.symbol); // 切换到当前 任务 task 对象保存的合约类型
if (!insDetail) { // 切换失败 立即返回
return self.ERR_SET_SYMBOL;
}
var ret = null;
var isCover = task.action != "buy" && task.action != "sell"; // 根据执行的动作，设置 是否是平仓的 标记
do { // do while 循环，先执行 do 以内
if (!$.IsTrading(task.symbol)) { // 判断是否在交易时间
return self.ERR_NOT_TRADING; // 不在交易时间立即返回
}
if (self.cancelAll(task.e) != self.ERR_SUCCESS) { // 调用全部取消函数 ，如果不等于 完成状态
return self.ERR_TRADE; // 返回交易失败
}
if (!CanTrade(task.amount)) { // 风控模块检测。
ret = null
break
}
var positions = task.e.GetPosition(); // 获取持仓信息
// Error
if (!positions) {
return self.ERR_GET_POS; // 如果调用获取持仓 API 错误，立即返回
}
// search position
var pos = null;
for (var i = 0; i < positions.length; i++) { // 遍历持仓信息，查找持仓合并持仓，类似 上面的 GetPosition 函数
if (positions[i].ContractType == task.symbol && (((positions[i].Type == PD_LONG || positions[i].Type == PD_LONG_YD) && (task.action == "buy" || task.action == "closebuy")) || ((positions[i].Type == PD_SHORT || positions[i].Type == PD_SHORT_YD) && (task.action == "sell" || task.action == "closesell")))) {
if (!pos) {
pos = positions[i];
pos.Cost = positions[i].Price * positions[i].Amount;
} else {
pos.Amount += positions[i].Amount;
pos.Profit += positions[i].Profit;
pos.Cost += positions[i].Price * positions[i].Amount;
}
}
}
// record pre position
if (!task.init) { // 如果任务没有初始化，执行以下
task.init = true; // 更新为已初始化
if (pos) { // 如果查找到之前的持仓，把之前的持仓数量、 花费 复制给task 的相应变量保存
task.preAmount = pos.Amount;
task.preCost = pos.Cost;
} else { // 如果执行这个任务 时没有 ，同样的方向 同样合约的持仓，把task相关变量赋值0
task.preAmount = 0;
task.preCost = 0;
if (isCover) { // 如果是 平仓动作，输出日志 ： 找不到仓位，跳出循环。
Log("找不到仓位", task.symbol, task.action);
ret = null;
break;
}
}
}
var remain = task.amount; // 声明一个局部变量，用 任务的属性 amount（任务设定的交易量） 初始化
if (isCover && !pos) { // 如果 第二次循环中 ， 该任务动作是平仓，并且 没有持仓了，给pos 赋值
pos = {Amount:0, Cost: 0, Price: 0}
}
if (pos) { // 如果 pos 不为null
task.dealAmount = pos.Amount - task.preAmount; // 已经处理的任务量 等于 每次获取的持仓信息持仓量 与最初开始循环的初始持仓信息持仓量的差值
if (isCover) { // 如果是 平仓动作， dealAmount 是负值， 这里取反操作
task.dealAmount = -task.dealAmount;
}
remain = parseInt(task.amount - task.dealAmount); // 任务的 交易量 减去 已经处理的交易量 得出 剩余需要处理的交易量
if (remain <= 0 || task.retry >= task.maxRetry) { // 如果剩余需要的交易量小于等于0（此处分析应该是不会小于0，有兴趣的可以分析下。） 或者重试次数大于最大重试上限.
ret = { // 更新ret 对象， 更新为已经成交的信息，和 当前仓位信息。
price: (pos.Cost - task.preCost) / (pos.Amount - task.preAmount),
amount: (pos.Amount - task.preAmount),
position: pos
};
if (isCover) { // 如果是 平仓动作
ret.amount = -ret.amount; // 平仓时计算出的是负值 ，取反操作
if (pos.Amount == 0) { // 如果持仓量为0了， 把ret 的持仓信息 赋值为 null
ret.position = null;
}
}
break; // remain <= 0 || task.retry >= task.maxRetry 符合这个条件，跳出while循环
}
} else if (task.retry >= task.maxRetry) { // 如果不是 平仓操作。pos 为null 没有持仓（平仓操作 pos 此处不会是null）
ret = null; // 并且 该任务重试测试 大于最大重试次数。跳出循环。
break; // 即此时 ， 超过最大重试次数，并且 没有增加持仓（开仓 每次都失败了。），跳出循环
}
var depth = task.e.GetDepth(); // 获取 深度数据
if (!depth) {
return self.ERR_GET_DEPTH; // 获取失败立即返回
}
var orderId = null; // 订单ID
var slidePrice = insDetail.PriceTick * SlideTick; // 计算具体滑价值
if (isCover) { // 如果是平仓操作
for (var i = 0; i < positions.length; i++) { // 遍历本轮的 API 返回的持仓信息。
if (positions[i].ContractType !== task.symbol) { // 不是当前任务 品种的 跳过。
continue;
}
if (parseInt(remain) < 1) { // 需要处理的 交易的量 如果小于1，跳出 while
break
}
var amount = Math.min(insDetail.MaxLimitOrderVolume, positions[i].Amount, remain); // 在合约规定的最大下单量、持仓量、需要处理的量中取最小值。
if (task.action == "closebuy" && (positions[i].Type == PD_LONG || positions[i].Type == PD_LONG_YD)) { // 如果是平多仓， 持仓信息 为 今日多仓 或者 昨日多仓
task.e.SetDirection(positions[i].Type == PD_LONG ? "closebuy_today" : "closebuy"); // 设置方向
amount = Math.min(amount, depth.Bids[0].Amount) // 根据盘口量 和 下单量 再取一个最小值。
orderId = task.e.Sell(_N(depth.Bids[0].Price - slidePrice, 2), amount, task.symbol, positions[i].Type == PD_LONG ? "平今" : "平昨", 'Bid', depth.Bids[0]);
// 执行具体的 API 操作，以下平空类似
} else if (task.action == "closesell" && (positions[i].Type == PD_SHORT || positions[i].Type == PD_SHORT_YD)) {
task.e.SetDirection(positions[i].Type == PD_SHORT ? "closesell_today" : "closesell");
amount = Math.min(amount, depth.Asks[0].Amount)
orderId = task.e.Buy(_N(depth.Asks[0].Price + slidePrice, 2), amount, task.symbol, positions[i].Type == PD_SHORT ? "平今" : "平昨", 'Ask', depth.Asks[0]);
}
// assume order is success insert
remain -= amount; // 假设是成功执行， 需要处理的交易量 减去 此次交易的量。
}
} else { // 开仓
if (task.action == "buy") {
task.e.SetDirection("buy");
orderId = task.e.Buy(_N(depth.Asks[0].Price + slidePrice, 2), Math.min(remain, depth.Asks[0].Amount), task.symbol, 'Ask', depth.Asks[0]);
} else {
task.e.SetDirection("sell");
orderId = task.e.Sell(_N(depth.Bids[0].Price - slidePrice, 2), Math.min(remain, depth.Bids[0].Amount), task.symbol, 'Bid', depth.Bids[0]);
}
}
// symbol not in trading or other else happend
if (!orderId) { // 没有返回具体的ID ，可能是 交易不在交易队列，或者其他错误。
task.retry++; // 累计重试次数
return self.ERR_TRADE; // 返回错误信息。即使不成功， 重新 执行该任务的时候 会重新一次流程。除了task对象的数据 所有数据都会刷新
}
} while (true); // 循环判断 恒为真
task.finished = true // 如果在 while 循环中没有直接 return 顺序执行到此，则任务完成
if (self.onTaskFinish) { // 如果队列控制对象的 回调函数 设置 不为null（即 self.onTaskFinish 存在）
self.onTaskFinish(task, ret) // 执行回调函数。把 task 任务 对象 和 交易的结果 ret 对象 传入回调函数。
}
if (task.onFinish) { // 处理 任务的回调函数
task.onFinish(task, ret);
}
return self.ERR_SUCCESS;
}
self.poll = function() { // 迭代执行 弹出 tasks 中的任务 ，并调用 pollTask 执行任务。
var processed = 0 // 未执行完成的任务计数 ，每次初始0
_.each(self.tasks, function(task) { // 迭代 可以搜索 _.each 的用法
if (!task.finished) { // 如果 任务不是完成状态，
processed++ // 未完成任务 计数 累计
self.pollTask(task) // 执行弹出的任务
}
})
if (processed == 0) { // 如果没有未完成的任务，即 所有任务队列内的任务完成 ，执行清空 队列对象中 tasks 数组.
self.tasks = []
}
}
self.size = function() { // 给队列对象添加 函数 size 获取 任务队列 中 任务个数
return self.tasks.length
}
return self // 返回构造好的队列对象
}
$.AccountToTable = AccountToTable;