ianzeng123
Jogo dos Aventureiros: Implementação de Código e Aplicação da Estratégia de Rolagem
0
353
[TOC]
introdução
No campo do trading quantitativo, a estratégia de posições rotativas é um tópico atraente, porém desafiador. A ideia central dessa estratégia é alcançar crescimento composto reinvestindo os lucros realizados em mercados em tendência. Este artigo irá explorar como traduzir essa ideia de trading em lógica de código executável, passo a passo, com foco na mudança de mentalidade em vez de detalhes técnicos. É importante ressaltar que, embora a estratégia de posições rotativas amplifique os retornos, ela também amplifica os riscos; este artigo tem fins meramente educativos e de discussão.
I. Análise detalhada da lógica de lucro da estratégia de posição rolante
1.1 A Essência Matemática da Rolagem
A lógica de lucro da estratégia de posição rolante é essencialmente umaModelo de crescimento compostoVamos entender isso usando um exemplo simplificado:
Negociação única tradicional (3 aumentos consecutivos de 10% cada):
- Capital inicial: 100 USDT, alavancagem de 3x
- Aumento de mercado: (1+10%) × (1+10%) × (1+10%) - 1 = 33,1%
- Lucro: 100 × 3 × 33,1% = 99,3 USDT
- Preço final: 199,3 USDT
Operações de rolagem (três operações consecutivas, cada uma com aumento de 10%):
- primeira vez100 USDT → Lucro de 30 USDT → Fundos passam a ser 130 USDT
- Cálculo: 100 × 3x alavancagem × aumento de 10% = 30
- 2ª vez130 USDT → Lucro de 39 USDT → Fundos passam a ser 169 USDT
- Cálculo: 130 × 3x alavancagem × aumento de 10% = 39
- 3º169 USDT → Lucro de 50,7 USDT → Fundos aumentaram para 219,7 USDT
- Cálculo: 169 × 3x alavancagem × aumento de 10% = 50,7
Resultados da comparação:
No mesmo cenário em que o mercado sobe 10% três vezes seguidas:
- transação únicaLucro de 99,3 USDT
- Negociação de rolagemLucro de 119,7 USDT
- Vantagens dos juros compostos20,4 USDT (um aumento de aproximadamente 20,5%)
Da mesma forma, com três aumentos consecutivos de 10% cada vez, o lucro para uma única negociação foi de 99,3 USDT e o lucro ao rolar a posição foi de 119,7 USDT.Essa diferença é o poder dos juros compostos.。
Expressando isso por meio de uma fórmula matemática:
// 传统交易：线性增长
最终资金 = 初始资金 × (1 + 杠杆 × 涨幅)
// 滚仓交易：指数增长
最终资金 = 初始资金 × (1 + 杠杆 × 单次涨幅) ^ 滚仓次数
Isso revela a essência do rollover:Transformando o crescimento linear em crescimento exponencial.No entanto, isso também expôs riscos:Uma única ordem de stop-loss poderia anular todos os ganhos compostos anteriores.。
1.2 Três questões centrais da estratégia de rollover
Antes de começarmos a escrever qualquer código, precisamos responder a três perguntas fundamentais de uma perspectiva estratégica:
Pergunta 1: Quando começa? (Primeira entrada)
É necessário determinar o sinal inicial de uma tendência.
Pergunta 2: Quando continuar? (Posição de rolamento adicional)
Este é o ponto crucial da rolagem de posições: como determinar se a tendência continuará após a realização dos lucros.
Pergunta 3: Quando parar? (Retirar-se e observar)
- Saída proativa: tendência de enfraquecimento
- Saída passiva: acionamento do stop loss
Essas três questões determinam a estrutura de toda a estratégia, e agora vamos traduzi-las em lógica de código uma a uma.
II. Pergunta 1: Quando começar? — Encontrando o ponto de inflexão para a entrada.
2.1 O Ideal e a Realidade da Estratégia de Rollover
Vamos primeiro entender o cenário de aplicação ideal para a estratégia de rolagem de posições.
Cenário ideal:
Imagine se você pudesse entrar no mercado SHIB quando ele começasse a subir a partir de US$ 0,000001, ou estabelecer uma posição pouco antes de uma determinada altcoin sofrer uma alta. Através do rollover contínuo, 100 USDT poderiam potencialmente se tornar 10.000 USDT ou até mais. Este é o sonho final da estratégia de rollover.Entre no mercado antes que a criptomoeda exploda e obtenha retornos dez vezes maiores ou até cem vezes maiores.。
A dura realidade:
O problema é: como saber qual criptomoeda terá uma alta expressiva? E quando essa alta ocorrerá?
- Se você é proprietário do projeto ou está envolvido com a empresa, pode ter conhecimento prévio de notícias positivas.
- Se você é um trader regular, só pode tomar decisões com base em sinais de mercado.
Para a maioria de nós, capturar com precisão esse ponto de inflexão é…Resumindo, tudo se resume à sorte.Não podemos prever o futuro; podemos apenas tentar aumentar a probabilidade de “ganhar na loteria” usando dados históricos e indicadores técnicos.
2.2 Do Ideal à Realidade: Simulação de Entrada Baseada em Indicadores Técnicos
Como não podemos prever qual criptomoeda terá um aumento significativo de valor, tudo o que podemos fazer é:Estabeleça um conjunto executável de regras de entrada e utilize indicadores técnicos para simular sinais de “início de tendência”.。
É como pescar no vasto oceano. Mesmo sem saber onde estão os peixes grandes, podemos:
- Observe as ondulações na superfície da água (flutuações de preço).
- Analise a direção do fluxo de água (direção da tendência).
- Escolha as ferramentas apropriadas (indicadores técnicos)
Quando vários sinais convergem, acreditamos que uma tendência pode estar prestes a começar, então entramos no mercado para testá-la. Se estivermos certos, seguimos a tendência e rolamos nossas posições para ganhar dinheiro; se estivermos errados, limitamos nossas perdas e saímos do mercado imediatamente.
2.3 Implementação Técnica do Sinal de Entrada
Escolhendo ferramentas técnicas:
Utilizamos o sistema de médias móveis exponenciais (EMA5 e EMA10) como ferramenta de identificação de tendências. A razão para essa escolha é simples:
- Simples, intuitivo e fácil de verificar.
- Capacidade de reagir rapidamente às mudanças de preço.
- Os parâmetros equilibram sensibilidade e estabilidade.
Lógica principal:
Ao detectar a “cruz de ouro” (EMA5 cruzando acima da EMA10) e a “cruz da morte” (EMA5 cruzando abaixo da EMA10) das médias móveis, é possível identificar pontos de reversão de tendência:
- Cruz dourada → Sinal de compra
- Cruz da morte → Sinal de venda a descoberto
A ideia do código:
// 计算EMA指标
var emaFast = TA.EMA(records, FastEMA); // EMA5
var emaSlow = TA.EMA(records, SlowEMA); // EMA10
// 获取当前和前一根K线的EMA值
var ema5_current = emaFast[emaFast.length - 1];
var ema5_prev = emaFast[emaFast.length - 2];
var ema10_current = emaSlow[emaSlow.length - 1];
var ema10_prev = emaSlow[emaSlow.length - 2];
// 检测金叉：前一根K线EMA5<=EMA10，当前K线EMA5>EMA10
var bullCross = ema5_prev <= ema10_prev && ema5_current > ema10_current;
// 检测死叉：前一根K线EMA5>=EMA10，当前K线EMA5<EMA10
var bearCross = ema5_prev >= ema10_prev && ema5_current < ema10_current;
// 空仓时等待信号入场
if (bullCross) {
Log("📈 金叉信号 - 做多");
openPosition("LONG", currentPrice);
} else if (bearCross) {
Log("📉 死叉信号 - 做空");
openPosition("SHORT", currentPrice);
}
Esta seção não abordará os detalhes das cruzes douradas e das cruzes da morte; esses são conceitos fundamentais no mercado financeiro. O ponto principal é:Precisamos de um sinal de entrada claro e quantificável para acionar o início da rolagem.。
III. Pergunta 2: Quando continuar? — O mecanismo central dos juros compostos.
3.1 Compreendendo a essência da rolagem: Um jogo de aventureiro racional
A estratégia de rollover é essencialmenteUm jogo de aventura racionalVamos entender isso usando um cenário completo:
Regras do jogo:
1. 你从交易所账户中拿出100 USDT作为冒险资金
2. 这100 USDT独立管理，与账户其他资金隔离
3. 用这100 USDT开始交易：
- 赚了 → 盈利加入资金池，继续用更大的资金交易（滚仓）
- 亏了 → 触发止损，回到空仓状态
4. 重复这个过程，直到：
- 要么把100 USDT亏完（游戏结束）
- 要么滚到一个满意的金额（主动退出）
A genialidade deste jogo reside em:
- O risco é administrável: a perda máxima é de 100 USDT, o que não afetará outros fundos na conta.
- Lucros ilimitados: Se a tendência estiver a seu favor, os juros compostos podem dobrar seu capital rapidamente.
- Regras bem definidas para entrada e saída: regras claras para realizar lucros, limitar perdas e renovar posições.
3.2 Estrutura do Fundo de Capital: A Chave para Alcançar Juros Compostos
Este é o conceito central do projeto da estratégia de posicionamento rotativo.
Problemas com as práticas tradicionais:
Supondo que sua conta na corretora tenha 1000 USDT:
- A primeira posição foi aberta com 100 USDT.
- Após obter um lucro de 30 USDT, o saldo da conta passou a ser de 1030 USDT.
- Quanto devo usar na segunda posição de abertura? 100 ou 130?
- Como podemos distinguir se o lucro provém da estratégia de rolagem de posições ou de outras operações?
Solução de angariação de fundos:
// 创建一个虚拟的"策略资金池"
var strategyCapital = InitialCapital; // 初始100 USDT
// 第1次交易
// 开仓金额 = 100 USDT
// 止盈后盈利 = 30 USDT
strategyCapital = strategyCapital + 30; // 资金池变为130 USDT
// 第2次交易（滚仓）
var positionValue = strategyCapital * Leverage; // 130 × 3 = 390
var amount = positionValue / price / ctVal; // 计算开仓数量
// 自动使用了第1次的盈利，这就是复利的关键
// 止盈后盈利 = 39 USDT
strategyCapital = strategyCapital + 39; // 资金池变为169 USDT
// 第3次交易（滚仓）
// 开仓金额 = 169 USDT（继续利滚利）
As vantagens deste projeto:
- Segregação de fundos:A estratégia utiliza apenas os 100 USDT especificados e não afeta outros fundos na conta.
- Juros compostos automáticos:Cada lucro é automaticamente adicionado ao capital inicial, de forma que um valor maior será utilizado na próxima posição.
- Os riscos são controláveis:O pior cenário possível é a perda de 100 USDT, o que está dentro das expectativas.
- Rastreamento claro:Ele consegue determinar com precisão quanto a estratégia reinvestiu de 100 USDT.
3.3 Decisão de Rollover: Continuar ou Parar Após Realizar o Lucro?
Este é o elemento central da estratégia de rolagem de posições:Após a execução da ordem de take-profit, precisamos tomar uma decisão crucial: continuar rolando ou parar?
Cenário de tomada de decisão:
假设我们做多BTC：
- 入场价：45000 USDT，用100 USDT开仓
- 止盈价：49500 USDT（涨10%）
- 止盈成交，盈利30 USDT
- 现在资金池：130 USDT
问题来了：
选项A：收手，带着130 USDT退出，回到空仓
选项B：继续，用130 USDT再次开多（滚仓）
Como escolher?
Essa decisão não pode ser baseada em “sentimentos”; devem existir critérios claros. Nossa lógica de julgamento é:Essa tendência vai continuar?
Método de julgamento:
No momento em que a ordem de take-profit é executada, os indicadores técnicos mais recentes (média móvel exponencial) são recalculados:
// 止盈单成交后，获取最新K线数据
var records = _C(exchange.GetRecords, PERIOD_M1);
var emaFast = TA.EMA(records, FastEMA);
var emaSlow = TA.EMA(records, SlowEMA);
var ema5_current = emaFast[emaFast.length - 1];
var ema10_current = emaSlow[emaSlow.length - 1];
var shouldRoll = false;
if (currentDirection == "LONG") {
// 多头止盈后，如果EMA5仍在EMA10上方，继续做多（滚仓）
if (ema5_current > ema10_current) {
shouldRoll = true;
Log("✅ EMA5 > EMA10，上升趋势未破坏");
Log("🔄 决策：继续做多（滚仓）");
} else {
Log("❌ EMA5 <= EMA10，趋势可能转弱");
Log("⏸️ 决策：不滚仓，等待新信号");
}
} else if (currentDirection == "SHORT") {
// 空头止盈后，如果EMA5仍在EMA10下方，继续做空（滚仓）
if (ema5_current < ema10_current) {
shouldRoll = true;
Log("✅ EMA5 < EMA10，下降趋势未破坏");
Log("🔄 决策：继续做空（滚仓）");
} else {
Log("❌ EMA5 >= EMA10，趋势可能转弱");
Log("⏸️ 决策：不滚仓，等待新信号");
}
}
3.4 Processo de Execução de Rollover
Se a decisão for “continuar rolando a posição”:
if (shouldRoll) {
// 1. 增加滚仓计数
currentRoundRolls++;
Log("🔄 执行滚仓操作... (本轮第", currentRoundRolls, "次滚仓)");
// 2. 获取最新价格
var ticker = _C(exchange.GetTicker);
var newPrice = ticker.Last;
// 3. 基于新资金池重新开仓
if (openPosition(currentDirection, newPrice)) {
Log("✅ 滚仓成功!");
// 4. 挂新的止盈单（在openPosition函数中完成）
// 5. 设置新的止损价（在checkStopLoss函数中监控）
} else {
Log("❌ 滚仓失败，等待新信号");
saveRollRecord(false);
resetPositionState();
}
}
Se a decisão for “parar”:
else {
// 1. 保存本轮统计
saveRollRecord(false); // false表示正常结束，非止损
// 2. 保留资金池金额
// strategyCapital 保持当前值，等待下次机会
// 3. 回到空仓状态
resetPositionState();
Log("⏳ 已平仓，等待新信号...");
}
Pontos-chave deste processo:
- Faça um julgamento imediatamente após cada ação que vise a obtenção de lucro, sem demora.
- Os critérios de avaliação são objetivos (relação entre médias móveis), sem especulação subjetiva.
- Continue aumentando sua posição; pare e preserve seus ganhos.
3.5 O Poder e o Custo dos Juros Compostos
Vamos vivenciar o poder dos juros compostos por meio de um estudo de caso completo:
Histórias de sucesso:
初始资金：100 USDT
止盈比例：10%
杠杆：3倍
第1次：100 USDT → 盈利30 → 资金池130
第2次：130 USDT → 盈利39 → 资金池169
第3次：169 USDT → 盈利50.7 → 资金池219.7
第4次：219.7 USDT → 盈利65.9 → 资金池285.6
第5次：285.6 USDT → 盈利85.7 → 资金池371.3
连续滚5次，100变成371.3，增长271%！
Caso de falha:
第1次：100 USDT → 盈利30 → 资金池130
第2次：130 USDT → 盈利39 → 资金池169
第3次：169 USDT → 趋势反转 → 触发止损
止损比例5%，亏损：169 × 3 × 5% = 25.35 USDT
剩余资金：169 - 25.35 = 143.65 USDT
原本从100滚到169，一次止损后只剩143.65
Essa é a faca de dois gumes das negociações de rollover:
- Após o sucesso:O crescimento exponencial é empolgante.
- Quando falha:Recuo rápido, ou mesmo perdas
IV. Pergunta 3: Quando parar? — O stop-loss é a última linha de defesa.
4.1 Dois métodos de saída
Saída proativa: tendência de enfraquecimento
Essa situação já foi abordada na “Questão Dois” — após realizar os lucros, se a tendência indicar que não há mais ganhos, opte ativamente por parar. Essa é a estratégia de saída ideal, deixando o mercado com lucro.
Saída passiva: acionamento do stop loss
É nisto que nos concentraremos agora: quando o mercado se move contra nós e o preço atinge a linha de stop-loss, somos obrigados a fechar as nossas posições.
4.2 A necessidade de stop-loss
Muitas pessoas não gostam de ordens de stop-loss porque:
- Stop-loss significa admitir um erro.
- O stop-loss resultará em perdas reais.
- Às vezes, o preço se recupera após a colocação de uma ordem de stop-loss.
No entanto, na estratégia de posição rolante,O stop-loss é a medida fundamental para a sobrevivência.Pense nisso:
如果没有止损：
第1次：100 → 滚到 169
第2次：169 → 趋势反转，不止损
价格持续下跌：169 → 150 → 120 → 80 → 50...
最终可能全亏，甚至爆仓
如果有止损：
第1次：100 → 滚到 169
第2次：169 → 趋势反转，触发止损
止损5%：亏损 25.35
剩余：143.65
虽然亏了，但保留了大部分资金
可以等待下一个机会
A essência do stop loss:Use perdas pequenas e certas para evitar riscos grandes e incertos.
4.3 Implementação do código stop-loss
// 检查止损
function checkStopLoss(currentPrice, position) {
var totalDrawdown = 0;
// 计算当前回撤
if (currentDirection == "LONG") {
totalDrawdown = (currentPrice - entryPrice) / entryPrice;
} else {
totalDrawdown = (entryPrice - currentPrice) / entryPrice;
}
// 判断是否触发止损
if (totalDrawdown < -StopLossPercent) {
Log("❌ 触发止损！回撤:", (totalDrawdown * 100).toFixed(2), "%");
// 1. 取消止盈单
if (takeProfitOrderId) {
Log("取消止盈单:", takeProfitOrderId);
exchange.CancelOrder(takeProfitOrderId);
takeProfitOrderId = null;
Sleep(500);
}
// 2. 市价平仓（循环重试直到成功）
var profit = closePositionMarketWithRetry(currentPrice, position);
// 3. 更新策略资金池
strategyCapital += profit; // profit是负数
totalProfitRealized += profit;
Log("止损亏损:", profit.toFixed(2), "U");
Log("策略剩余资金:", strategyCapital.toFixed(2), "U");
// 4. 记录本轮止损亏损
currentRoundLoss = Math.abs(profit);
Log("本轮止损亏损:", currentRoundLoss.toFixed(2), "U");
// 5. 保存本轮滚仓记录（被止损中断）
saveRollRecord(true); // true表示止损结束
// 6. 重置状态
resetPositionState();
// 7. 检查资金是否充足
if (strategyCapital < 10) {
Log("💥 策略资金不足10U，停止运行");
throw "资金不足";
}
Log("⏳ 已止损，等待新信号...");
}
}
4.4 Condições para o término do jogo
Lembra do “Jogo do Aventureiro Racional” de que falamos? Esse jogo tem uma condição de término bem definida:
Condição 1: O capital disponível é reduzido a zero.
if (strategyCapital <= 0) {
Log("💥 游戏结束：资金池已归零");
Log("本次冒险失败，100 USDT全部亏光");
throw "资金耗尽";
}
Condição 2: Retirada voluntária
if (strategyCapital >= 目标金额) {
Log("🎉 达到目标金额，可以选择主动退出");
Log("锁定利润，开始新一轮100 USDT的游戏");
}
Condição 3: Atingir o número máximo de rollovers
if (连续滚仓次数 >= 10次) {
Log("⚠️ 达到最大滚仓次数，主动退出");
Log("持续时间太长，风险累积，见好就收");
saveRollRecord(false);
resetPositionState();
}
4.5 O equilíbrio entre risco e retorno
O cerne de toda a estratégia de posicionamento rotativo está emEncontrar um equilíbrio entre risco e retorno.：
Lado da receita:
- Crescimento composto: O capital inicial aumenta após cada realização de lucros.
- Captura de tendências: Lucrar consistentemente em tendências de alta/baixa.
- Sem limite superior: Teoricamente, pode rolar indefinidamente.
Lado de risco:
- Proteção contra stop-loss: Perda máxima de 5% do capital total em uma única transação.
- Segregação de fundos: Perda máxima de 100 USDT
- Análise de tendências: Evite ordens de stop-loss frequentes em um mercado volátil.
V. Backtesting Prático: Análise de Caso TRUMP_USDT
TRUMP_USDTAnálise de backtesting do primeiro dia de listagem da Binance Futures (20 de janeiro de 2025 a 21 de janeiro de 2025):
Os resultados do backtest mostram que:
Destaques:
- A estratégia capturou com sucesso as flutuações dramáticas nos primeiros dias da Trump após seu IPO.
- Por meio de múltiplas renovações de capital, foi alcançado um rápido crescimento do capital.
- O mecanismo de realização de lucros efetivamente consolida os lucros dentro de uma tendência.
Exposição ao risco:
- Quando a tendência se inverte, as ordens de stop-loss fazem com que parte dos lucros seja devolvida.
- Um sinal falso de rompimento surgiu em um mercado volátil.
- O risco de concentração é maior com uma única moeda.
Dados principais:
- Número total de rollovers: X vezes
- Acumulação máxima de rodadas: X vezes
- Redução máxima: X%
- Taxa de retorno final: X%
VI. A natureza e as limitações da estratégia
6.1 O que essa estratégia está simulando?
Através da análise acima, podemos ver claramente que essa estratégia é essencialmente uma simulação:
O comportamento comercial de um aventureiro racional:
- Existem regras de entrada claras (não se trata de negociação impulsiva).
- Defina uma meta de lucro (evite a ganância).
- Tenha disciplina de stop-loss (não mantenha posições perdedoras).
- Possui a capacidade de tomar decisões de posicionamento rotativas (e utilizar os lucros).
- Existem restrições de financiamento (para controlar o risco).
Sua lógica fundamental é:
- Reserve uma quantia fixa de capital (100 USDT) para experimentar.
- Ganhe dinheiro seguindo tendências.
- Após obter lucro, utilize-o para continuar negociando (efeito composto dos lucros).
- Se a tendência enfraquecer, pare imediatamente.
- Se o julgamento estiver errado, minimize suas perdas rapidamente.
- Até que os fundos se esgotem ou sejam transferidos para um montante satisfatório.
6.2 Limitações da Estratégia
Limitação 1: Dependência de mercados de tendência
Essa estratégia apresenta baixo desempenho em mercados voláteis porque:
- Falsos erupções frequentes
- O preço recuou depois que realizei o lucro, então não consegui rolar a posição.
- Ordens repetidas de stop-loss esgotam o capital disponível.
Limitação 2: Sensibilidade dos parâmetros
Parâmetros como meta de lucro de 10% e stop loss de 5% não são ideais:
- Moedas diferentes apresentam volatilidade diferente.
- Diferentes condições de mercado exigem parâmetros diferentes.
- Parâmetros fixos são difíceis de adaptar a todas as situações.
Limitação 3: Ponto de detonação imprevisível
Como mencionado anteriormente, usar indicadores técnicos para entrar no mercado é essencialmente uma aposta:
- Você pode perder as grandes movimentações do mercado.
- Entrar durante uma falsa fuga
- Incapazes de planejar com antecedência como os especialistas.
6.3 Áreas para melhoria
Opção 1: Filtrar moedas com base no fluxo de trabalho
- Não escolha qualquer criptomoeda e saia por aí.
- Em vez disso, o fluxo de trabalho é usado para filtrar primeiramente as criptomoedas populares e de alto potencial.
- Por exemplo: um aumento repentino nas discussões em redes sociais, um volume anormal de transações e dados ativos na blockchain.
- Utilizar uma estratégia de rotação de posições nessas criptomoedas resultará em uma taxa de sucesso maior.
Direção 2: Ajustar parâmetros dinamicamente
- Ajuste os índices de realização de lucros e de stop-loss com base na volatilidade histórica da moeda.
- Para moedas altamente voláteis, amplie adequadamente o intervalo de stop-loss.
- Para criptomoedas com baixa volatilidade, você pode reduzir sua meta de lucro.
Diretriz 3: Múltiplos fundos operando em paralelo
- Não se trata de colocar 100 USDT em uma única moeda.
- Em vez disso, é dividido em cinco quantias de 20 USDT, que são transferidas simultaneamente para cinco criptomoedas diferentes.
- Diversifique o risco e aumente a probabilidade de “ganhar na loteria”.
Conclusão
Por meio da dedução de três questões fundamentais, demonstramos plenamente como traduzir a ideia de rolagem de posições em lógica de código. A essência desse processo é:Expresse a mentalidade de negociação de um investidor racional que assume riscos, utilizando regras e estruturas de dados precisas.
Nota importante:
Esta é apenas uma simulação da estratégia de rolagem de posições. Na realidade, a rolagem de posições é uma estratégia de negociação que exige muita experiência de mercado. Esta estratégia é apenas uma ferramenta. Posteriormente, ela poderá ser combinada com fluxos de trabalho para identificar criptomoedas populares ou com potencial de explosão. O uso desta ferramenta nos trará mais surpresas.
Lembre-se:
- A perda máxima é de 100 USDT, e o risco é administrável.
- Se você tiver a sorte de identificar uma grande tendência, seu investimento poderá se multiplicar várias vezes ou até dezenas de vezes.
- Mas, na maioria das vezes, isso pode envolver pequenos ganhos e perdas, e testes repetidos.
- Este é um jogo que exige paciência e disciplina.
Não existe estratégia que garanta lucro.A troca de posições é apenas uma ferramenta. O que realmente determina o sucesso ou o fracasso é a sua capacidade de:
- Identificar criptomoedas promissoras (usando filtragem de fluxo de trabalho).
- Respeite as ordens de stop-loss (não se apegue teimosamente à posição).
- Tenha a ousadia de rolar suas posições quando uma tendência importante surgir (não saia muito cedo).
- Mantenha a racionalidade (não deixe que suas emoções o controlem).
Que todos vocês encontrem sua própria “grande sorte” em sua jornada de negociação quantitativa!
Endereço completo da política:**Código-fonte da estratégia -> ** https://www.fmz.com/strategy/521864
Código de estratégia completo:
”`js /*backtest start: 2025-01-20 00:00:00 end: 2025-01-21 00:00:00 period: 1m basePeriod: 1m exchanges: [{“eid”:“Futures_Binance”,“currency”:“TRUMP_USDT”,“balance”:5000}] */
// ============================================ // 滚仓策略 - EMA5/EMA10 简化版 // 使用 CreateOrder 统一下单 // 持续检测订单状态 // 止盈后根据EMA关系决定是否滚仓 // 新增:滚仓统计功能(三个两行表格) // 修复:方向记录、亏损记录、入场价格记录 // 优化:市价平仓循环重试直到成功 // 优化:滚仓统计表格新增开始/结束时间 // ============================================
// ========== 策略参数(可调整)========== var Symbol = “TRUMP_USDT.swap”; // 交易币种 var InitialCapital = 100; // 策略初始资金 100U var Leverage = 3; // 杠杆倍数 var RollProfitPercent = 0.10; // 滚仓盈利系数(10% = 0.10) var StopLossPercent = 0.05; // 止损系数(10% = 0.10)
// EMA参数 var FastEMA = 5; var SlowEMA = 10;
// 全局变量 var strategyCapital = InitialCapital; var entryPrice = 0; var lastRollPrice = 0; var rollCount = 0; var totalProfitRealized = 0; var currentDirection = “”; var takeProfitOrderId = null; // 止盈单ID var amountPrecision = 0; // 数量精度 var pricePrecision = 2; // 价格精度 var ctVal = 1; // 合约面值
// ========== 滚仓统计变量 ========== var currentRoundRolls = 0; // 本轮滚仓次数(连续滚仓) var currentRoundStartTime = 0; // 本轮开始时间 var currentRoundDirection = “”; // 本轮方向 var currentRoundTotalProfit = 0; // 本轮累计盈利(每次止盈累加) var currentRoundLoss = 0; // 本轮亏损(止损时记录) var currentRoundEntryPrice = 0; // 本轮入场价格 var rollHistory = []; // 滚仓历史记录 var maxHistoryRecords = 10; // 保留最近10次滚仓记录
function main() { Log(“=== EMA滚仓策略启动(CreateOrder模式 + 滚仓统计)===”); Log(“交易币种:”, Symbol); Log(“━━━━━━━━━━━━━━━━━━━━”);
// 获取市场信息
var markets = exchange.GetMarkets();
if (!markets || !markets[Symbol]) {
Log("❌ 错误:无法获取", Symbol, "的市场信息");
return;
}
var marketInfo = markets[Symbol];
amountPrecision = marketInfo.AmountPrecision;
pricePrecision = marketInfo.PricePrecision || 2;
ctVal = marketInfo.CtVal;
Log("市场信息:");
Log(" - 数量精度:", amountPrecision);
Log(" - 价格精度:", pricePrecision);
Log(" - 合约面值:", ctVal);
var account = _C(exchange.GetAccount);
Log("账户总资金:", account.Balance.toFixed(2), "U");
Log("策略使用资金:", InitialCapital, "U");
Log("杠杆倍数:", Leverage, "倍");
Log("滚仓系数:", (RollProfitPercent * 100), "%");
Log("止损系数:", (StopLossPercent * 100), "%");
Log("━━━━━━━━━━━━━━━━━━━━");
if (account.Balance < InitialCapital) {
Log("❌ 错误:账户余额不足");
return;
}
exchange.SetContractType("swap");
exchange.SetMarginLevel(Leverage);
var lastBarTime = 0;
while (true) {
var records = _C(exchange.GetRecords, PERIOD_M1);
if (records.length < SlowEMA + 5) {
Sleep(3000);
continue;
}
var currentBarTime = records[records.length - 1].Time;
if (currentBarTime == lastBarTime) {
Sleep(1000);
continue;
}
lastBarTime = currentBarTime;
var ticker = _C(exchange.GetTicker);
var currentPrice = ticker.Last;
var account = _C(exchange.GetAccount);
var position = _C(exchange.GetPositions);
// 计算EMA
var emaFast = TA.EMA(records, FastEMA);
var emaSlow = TA.EMA(records, SlowEMA);
if (emaFast.length < 3 || emaSlow.length < 3) {
Sleep(3000);
continue;
}
var ema5_current = emaFast[emaFast.length - 1];
var ema5_prev = emaFast[emaFast.length - 2];
var ema10_current = emaSlow[emaSlow.length - 1];
var ema10_prev = emaSlow[emaSlow.length - 2];
var isBullTrend = ema5_current > ema10_current;
var isBearTrend = ema5_current < ema10_current;
var bullCross = ema5_prev <= ema10_prev && ema5_current > ema10_current;
var bearCross = ema5_prev >= ema10_prev && ema5_current < ema10_current;
if(takeProfitOrderId){
checkTakeProfitOrder();
}
// ========== 持仓逻辑 ==========
if (position.length > 0) {
var pos = position[0];
currentDirection = pos.Type == PD_LONG ? "LONG" : "SHORT";
if (entryPrice == 0) {
entryPrice = pos.Price;
lastRollPrice = pos.Price;
}
// 检查止损
checkStopLoss(currentPrice, pos);
} else {
// ========== 空仓:等待信号 ==========
if (bullCross) {
Log("📈 金叉信号 - 做多");
openPosition("LONG", currentPrice);
} else if (bearCross) {
Log("📉 死叉信号 - 做空");
openPosition("SHORT", currentPrice);
}
}
showStatus(account, position, currentPrice, ema5_current, ema10_current, isBullTrend, currentBarTime);
Sleep(1000);
}
}
// 开仓(持续检测订单状态) function openPosition(direction, price) { Log(“🚀 开仓”, direction == “LONG” ? “做多” : “做空”); Log(“使用资金:”, strategyCapital.toFixed(2), “U”);
var positionValue = strategyCapital * Leverage;
var amount = _N(positionValue / price / ctVal, amountPrecision);
Log("计算数量:", amount, "| 持仓价值:", positionValue.toFixed(2), "U");
if (amount <= 0) {
Log("❌ 数量无效");
return false;
}
// 使用 CreateOrder 市价开仓
var orderId = exchange.CreateOrder(Symbol, direction == "LONG" ? "buy" : "sell", -1, amount);
if (!orderId) {
Log("❌ 下单失败");
return false;
}
Log("订单ID:", orderId, "开始持续检测...");
// 持续检测订单状态,直到成交或超时
var maxWaitTime = 30000; // 最多等待30秒
var startTime = Date.now();
var checkCount = 0;
while (Date.now() - startTime < maxWaitTime) {
Sleep(500);
checkCount++;
var order = exchange.GetOrder(orderId);
if (!order) {
Log("❌ 无法获取订单信息");
continue;
}
if (order.Status == 1) {
// 订单已成交
var avgPrice = order.AvgPrice;
entryPrice = avgPrice;
lastRollPrice = avgPrice;
currentDirection = direction;
// ========== 修改:无论是否第一次,都要初始化/更新统计数据 ==========
if (currentRoundRolls == 0) {
// 第一次开仓:初始化所有统计数据
currentRoundStartTime = Date.now();
currentRoundDirection = direction;
currentRoundTotalProfit = 0;
currentRoundLoss = 0;
currentRoundEntryPrice = avgPrice;
Log("🆕 开始新一轮交易统计");
Log(" - 开始时间:", _D(currentRoundStartTime));
Log(" - 方向:", direction == "LONG" ? "🟢 多头" : "🔴 空头");
Log(" - 入场价格:", avgPrice.toFixed(pricePrecision));
} else {
// 滚仓时:更新方向(理论上应该相同,但为了健壮性还是更新)
currentRoundDirection = direction;
Log("🔄 滚仓操作 (第", currentRoundRolls, "次)");
Log(" - 方向:", direction == "LONG" ? "🟢 多头" : "🔴 空头");
Log(" - 入场价格:", avgPrice.toFixed(pricePrecision));
}
Log("✅ 开仓成功!");
Log(" - 成交均价:", avgPrice.toFixed(pricePrecision));
Log(" - 成交数量:", order.DealAmount);
Log(" - 成交金额:", (order.DealAmount * avgPrice * ctVal).toFixed(2), "U");
// 挂止盈单
Sleep(1000);
placeTakeProfitOrder(direction, avgPrice, order.DealAmount);
return true;
} else if (order.Status == 2) {
// 订单已取消
Log("❌ 订单已取消");
return false;
}
// Status == 0 表示未成交,继续等待
}
// 超时未成交
Log("⚠️ 订单超时,尝试取消订单");
exchange.CancelOrder(orderId);
return false;
}
// 挂止盈单 function placeTakeProfitOrder(direction, entryPrice, amount) { var takeProfitPrice = 0;
if (direction == "LONG") {
takeProfitPrice = _N(entryPrice * 1.1, pricePrecision); // 多头止盈:+10%
} else {
takeProfitPrice = _N(entryPrice * 0.9, pricePrecision); // 空头止盈:-10%
}
Log("📌 挂止盈单");
Log(" - 入场价格:", entryPrice.toFixed(pricePrecision));
Log(" - 止盈价格:", takeProfitPrice);
Log(" - 数量:", amount);
// 使用 CreateOrder 挂限价止盈单
if (direction == "LONG") {
takeProfitOrderId = exchange.CreateOrder(Symbol, "closebuy", takeProfitPrice, amount);
} else {
takeProfitOrderId = exchange.CreateOrder(Symbol, "closesell", takeProfitPrice, amount);
}
if (takeProfitOrderId) {
Log("✅ 止盈单已挂,订单ID:", takeProfitOrderId);
} else {
Log("❌ 止盈单挂单失败");
}
}
// 检查止盈单状态 function checkTakeProfitOrder() {
if (!takeProfitOrderId) {
return;
}
var order = exchange.GetOrder(takeProfitOrderId);
if (!order) {
return;
}
if (order.Status == 1) {
// 止盈单成交
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
Log("💰 止盈单成交!");
Log(" - 成交价格:", order.AvgPrice.toFixed(pricePrecision));
Log(" - 成交数量:", order.DealAmount);
// 使用订单数据精确计算盈利
var profit = 0;
if (currentDirection == "LONG") {
// 多头盈利 = (止盈价 - 入场价) * 数量 * 合约面值
profit = (order.AvgPrice - entryPrice) * order.DealAmount * ctVal;
} else {
// 空头盈利 = (入场价 - 止盈价) * 数量 * 合约面值
profit = (entryPrice - order.AvgPrice) * order.DealAmount * ctVal;
}
// 计算盈利率
var profitRate = profit / strategyCapital;
Log("📊 盈利统计:");
Log(" - 入场价格:", entryPrice.toFixed(pricePrecision));
Log(" - 止盈价格:", order.AvgPrice.toFixed(pricePrecision));
Log(" - 本次盈利:", profit.toFixed(2), "U");
Log(" - 盈利率:", (profitRate * 100).toFixed(2), "%");
Log(" - 策略资金(盈利前):", strategyCapital.toFixed(2), "U");
// 更新资金
strategyCapital += profit;
totalProfitRealized += profit;
rollCount++;
Log(" - 策略资金(盈利后):", strategyCapital.toFixed(2), "U");
Log(" - 累计盈利:", totalProfitRealized.toFixed(2), "U");
Log(" - 滚仓次数:", rollCount, "次");
// ========== 累加本轮盈利 ==========
currentRoundTotalProfit += profit;
Log(" - 本轮累计盈利:", currentRoundTotalProfit.toFixed(2), "U");
// 重置止盈单ID
takeProfitOrderId = null;
// 获取最新K线计算EMA
Sleep(1000);
var records = _C(exchange.GetRecords, PERIOD_M1);
var emaFast = TA.EMA(records, FastEMA);
var emaSlow = TA.EMA(records, SlowEMA);
if (emaFast.length < 2 || emaSlow.length < 2) {
Log("⚠️ EMA数据不足,无法判断是否滚仓");
// 记录本轮滚仓结束(正常结束,之前有盈利)
saveRollRecord(false);
resetPositionState();
Log("⏳ 等待新信号...");
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
return;
}
var ema5_current = emaFast[emaFast.length - 1];
var ema10_current = emaSlow[emaSlow.length - 1];
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
Log("📈 EMA滚仓判断:");
Log(" - EMA5:", ema5_current.toFixed(pricePrecision));
Log(" - EMA10:", ema10_current.toFixed(pricePrecision));
Log(" - 原持仓方向:", currentDirection);
var shouldRoll = false;
if (currentDirection == "LONG") {
// 多头止盈后,如果EMA5仍在EMA10上方,继续做多(滚仓)
if (ema5_current > ema10_current) {
shouldRoll = true;
Log(" - 判断结果: ✅ EMA5 > EMA10,趋势延续");
Log(" - 决策: 🔄 继续做多(滚仓)");
} else {
Log(" - 判断结果: ❌ EMA5 <= EMA10,趋势转弱");
Log(" - 决策: ⏸️ 不滚仓,等待新信号");
}
} else if (currentDirection == "SHORT") {
// 空头止盈后,如果EMA5仍在EMA10下方,继续做空(滚仓)
if (ema5_current < ema10_current) {
shouldRoll = true;
Log(" - 判断结果: ✅ EMA5 < EMA10,趋势延续");
Log(" - 决策: 🔄 继续做空(滚仓)");
} else {
Log(" - 判断结果: ❌ EMA5 >= EMA10,趋势转弱");
Log(" - 决策: ⏸️ 不滚仓,等待新信号");
}
}
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
if (shouldRoll) {
// ========== 滚仓:增加本轮滚仓次数 ==========
currentRoundRolls++;
Log("🔄 执行滚仓操作... (本轮第", currentRoundRolls, "次滚仓)");
Sleep(1000);
var ticker = _C(exchange.GetTicker);
var newPrice = ticker.Last;
if (openPosition(currentDirection, newPrice)) {
Log("✅ 滚仓成功!");
} else {
Log("❌ 滚仓失败,等待新信号");
// 记录本轮滚仓结束(滚仓失败,但之前有盈利)
saveRollRecord(false);
resetPositionState();
}
} else {
// ========== 不滚仓:记录本轮滚仓结束 ==========
saveRollRecord(false);
resetPositionState();
Log("⏳ 已平仓,等待新信号...");
}
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
}
}
// ========== 保存滚仓记录 ========== function saveRollRecord(isStopLoss) { // 必须有开始时间才记录(防止异常情况) if (currentRoundStartTime == 0) { Log(“⚠️ 本轮未正确初始化,跳过记录”); currentRoundRolls = 0; currentRoundTotalProfit = 0; currentRoundLoss = 0; currentRoundDirection = “”; currentRoundEntryPrice = 0; return; }
var endTime = Date.now();
var duration = endTime - currentRoundStartTime;
// 计算总体盈利 = 累计盈利 - 亏损
var netProfit = currentRoundTotalProfit - currentRoundLoss;
var record = {
direction: currentRoundDirection, // 本轮方向
roundRolls: currentRoundRolls, // 本轮滚仓次数
totalProfit: currentRoundTotalProfit, // 累计盈利(止盈累加)
loss: currentRoundLoss, // 亏损金额(止损)
netProfit: netProfit, // 总体盈利
duration: duration, // 持续时间(毫秒)
isStopLoss: isStopLoss, // 是否止损结束
startTime: currentRoundStartTime, // 开始时间
endTime: endTime, // 结束时间
entryPrice: currentRoundEntryPrice // 入场价格
};
rollHistory.push(record);
// 只保留最近N条记录
if (rollHistory.length > maxHistoryRecords) {
rollHistory.shift();
}
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
Log("📝 保存滚仓记录:");
Log(" - 方向:", currentRoundDirection == "LONG" ? "🟢 多头" : "🔴 空头");
Log(" - 入场价格:", currentRoundEntryPrice.toFixed(pricePrecision));
Log(" - 开始时间:", _D(currentRoundStartTime));
Log(" - 结束时间:", _D(endTime));
Log(" - 持续时间:", formatDuration(duration));
Log(" - 本轮滚仓次数:", currentRoundRolls);
Log(" - 累计盈利:", currentRoundTotalProfit.toFixed(2), "U");
Log(" - 亏损金额:", currentRoundLoss.toFixed(2), "U");
Log(" - 总体盈利:", netProfit.toFixed(2), "U");
Log(" - 结束方式:", isStopLoss ? "❌ 止损" : "✅ 正常");
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
// 重置本轮统计数据
currentRoundRolls = 0;
currentRoundStartTime = 0;
currentRoundDirection = "";
currentRoundTotalProfit = 0;
currentRoundLoss = 0;
currentRoundEntryPrice = 0;
}
// 格式化时长 function formatDuration(ms) { var seconds = Math.floor(ms / 1000); var minutes = Math.floor(seconds / 60); var hours = Math.floor(minutes / 60); var days = Math.floor(hours / 24);
if (days > 0) {
return days + "天" + (hours % 24) + "时" + (minutes % 60) + "分";
} else if (hours > 0) {
return hours + "时" + (minutes % 60) + "分";
} else if (minutes > 0) {
return minutes + "分" + (seconds % 60) + "秒";
} else {
return seconds + "秒";
}
}
// 重置持仓状态函数 function resetPositionState() { entryPrice = 0; lastRollPrice = 0; currentDirection = “”; // 注意:不重置 rollCount、strategyCapital 和 currentRoundRolls }
// 检查止损 function checkStopLoss(currentPrice, position) { var totalDrawdown = 0;
if (currentDirection == "LONG") {
totalDrawdown = (currentPrice - entryPrice) / entryPrice;
} else {
totalDrawdown = (entryPrice - currentPrice) / entryPrice;
}
if (totalDrawdown < -StopLossPercent) {
Log("❌ 触发止损!回撤:", (totalDrawdown * 100).toFixed(2), "%");
// 取消止盈单
if (takeProfitOrderId) {
Log("取消止盈单:", takeProfitOrderId);
exchange.CancelOrder(takeProfitOrderId);
takeProfitOrderId = null;
Sleep(500);
}
// ========== 市价平仓(循环重试直到成功) ==========
var profit = closePositionMarketWithRetry(currentPrice, position);
// 更新策略资金池
strategyCapital += profit;
totalProfitRealized += profit;
Log("止损亏损:", profit.toFixed(2), "U");
Log("策略剩余资金:", strategyCapital.toFixed(2), "U");
Log("累计盈利:", totalProfitRealized.toFixed(2), "U");
// ========== 记录本轮止损亏损 ==========
currentRoundLoss = Math.abs(profit); // 转为正数保存
Log("本轮止损亏损:", currentRoundLoss.toFixed(2), "U");
// ========== 记录本轮滚仓结束(被止损中断) ==========
saveRollRecord(true);
// 重置状态
resetPositionState();
if (strategyCapital < 10) {
Log("💥 策略资金不足10U,停止运行");
throw "资金不足";
}
Log("⏳ 已止损,等待新信号...");
}
}
// ========== 市价平仓(带重试机制,直到成功) ========== function closePositionMarketWithRetry(currentPrice, position) { Log(“🔴 市价平仓(循环重试模式)”);
var maxRetries = 10; // 最多重试10次
var retryCount = 0;
while (retryCount < maxRetries) {
retryCount++;
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
Log("🔄 第", retryCount, "次平仓尝试");
var profit = closePositionMarket(currentPrice, position);
// 如果返回值不为0,说明平仓成功
if (profit !== 0) {
Log("✅ 平仓成功!");
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
return profit;
}
// 平仓失败,检查持仓是否还存在
Sleep(2000);
var newPosition = _C(exchange.GetPosition);
if (newPosition.length == 0) {
Log("⚠️ 持仓已不存在,可能已被其他途径平仓");
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
return 0;
}
// 更新position和currentPrice
position = newPosition[0];
var ticker = _C(exchange.GetTicker);
currentPrice = ticker.Last;
Log("⚠️ 平仓失败,", (maxRetries - retryCount), "次重试机会剩余");
Log("等待3秒后重试...");
Sleep(3000);
}
// 所有重试都失败
Log("❌ 平仓失败!已达到最大重试次数");
Log("⚠️ 请手动检查持仓状态!");
Log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
return 0;
}
// 市价平仓(持续检测订单状态) function closePositionMarket(currentPrice, position) { Log(“📤 发起市价平仓订单”);
var pos = position;
var amount = pos.Amount;
if (pos.Type == PD_LONG) {
exchange.SetDirection("closebuy");
} else {
exchange.SetDirection("closesell");
}
// 市价平仓
var orderType = pos.Type == PD_LONG ? "closebuy" : "closesell";
var orderId = exchange.CreateOrder(Symbol, orderType, -1, amount);
if (!orderId) {
Log("❌ 平仓下单失败");
return 0;
}
Log("平仓订单ID:", orderId, "开始持续检测...");
// 持续检测订单状态
var maxWaitTime = 30000; // 单次等待最多30秒
var startTime = Date.now();
var checkCount = 0;
while (Date.now() - startTime < maxWaitTime) {
Sleep(500);
checkCount++;
var order = exchange.GetOrder(orderId);
if (!order) {
Log("❌ 无法获取订单信息(检测", checkCount, "次)");
continue;
}
if (order.Status == 1) {
// 平仓成功
Log("✅ 订单成交,成交价:", order.AvgPrice.toFixed(pricePrecision));
var profit = calculateProfit(pos, order.AvgPrice);
Log("盈亏:", profit.toFixed(2), "U");
return profit;
} else if (order.Status == 2) {
Log("❌ 平仓订单已被取消");
return 0;
}
// Status == 0 表示未成交,继续等待
if (checkCount % 10 == 0) {
Log("⏳ 订单未成交,已检测", checkCount, "次...");
}
}
// 超时,取消订单
Log("⚠️ 平仓订单超时(等待30秒未成交)");
Log("尝试取消订单:", orderId);
var cancelResult = exchange.CancelOrder(orderId);
if (cancelResult) {
Log("✅ 订单已取消");
} else {
Log("⚠️ 取消