VXRpbGl6em8gZGVsbGEgQ2hhbmRlIEtyb2xsIFN0b3A6IGxhIHN0cmF0ZWdpYSBkaSBzdG9wLWxvc3MgZSB0YWtlLXByb2ZpdA==

2023-01-05, 08:01

<p><img src="https://gimg2.gateimg.com/image/article/1672905360交易指南.jpeg" alt=""></p>
<h2 id="h2-TL20DR850397"><a name="TL; DR" class="reference-link"></a><span class="header-link octicon octicon-link"></span>TL; DR</h2><p>Questo indicatore calcola e mostra i punti di stop loss e take profit di un asset.</p>
<p>I trader possono utilizzare l’indicatore di stop Chande Kroll per individuare inversioni di tendenza, nonché punti di ingresso e uscita dal commercio.</p>
<p>Le due linee dell’indicatore Chande Kroll Stop indicano un livello di resistenza importante sul lato superiore e un livello di supporto sul lato inferiore del prezzo di un asset.</p>
<h2 id="h2-Introduzione145850"><a name="Introduzione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Introduzione</h2><p>Molti trader utilizzano vari modelli di candele, indicatori e strumenti durante il trading per prendere decisioni rapide e affidabili. La maggior parte di questi trader combina diversi indicatori per ottenere i migliori segnali. Naturalmente, ci sono vari tipi di indicatori tecnici che includono oscillatori e indicatori di volume. Tuttavia, la Chande Kroll Stop è un indicatore che ogni trader dovrebbe combinare con altri indicatori. Questo articolo ti aiuterà a capire perché dovresti utilizzare l’indicatore Chande Kroll Stop e come utilizzarlo.</p>
<h2 id="h2-Cos20lindicatore20di20stop20Chande20Kroll590026"><a name="Cos’è l’indicatore di stop Chande Kroll?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cos’è l’indicatore di stop Chande Kroll?</h2><p>L’indicatore di stop Chande Kroll calcola i prezzi di take-profit e stop-loss di diverse criptovalute come <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> e Ether (ETH). È anche utile in altri mercati, inclusi i mercati forex e delle materie prime. Gli operatori utilizzano questo indicatore su diversi intervalli di tempo di negoziazione come 1M, 1W, 1D, 6H. Tuttavia, fornisce i migliori segnali quando viene utilizzato con intervalli di tempo medio-lunghi.</p>
<p>È importante notare anche che la Chande Kroll Stop è un indicatore di trend-following che fornisce un’idea sulla volatilità del mercato in tempo reale basata sui movimenti del prezzo dell’attività. Calcola anche i livelli di take-profit e stop-loss utilizzando la media della gamma di vera volatilità del titolo.</p>
<h2 id="h2-La20storia20dellindicatore20di20arresto20Chande20Kroll128819"><a name="La storia dell’indicatore di arresto Chande Kroll" class="reference-link"></a><span class="header-link octicon octicon-link"></span>La storia dell’indicatore di arresto Chande Kroll</h2><p>Due banchieri canadesi, Tushar Chande e Stanely Kroll, hanno sviluppato l’indicatore Chande Kroll Stop. Come si nota, il nome di questo indicatore deriva dai loro cognomi. È stato pubblicato nel loro libro, “Il Nuovo Trader Tecnico - Aumenta i tuoi profitti collegandoti agli ultimi indicatori”, nel 1994.</p>
<p>I due analisti tecnici, Chande e Kroll, hanno anche sviluppato vari indicatori che includono l’oscillatore di momentum di Chande, Aroon, StochRSI e VIDYA. Il diagramma seguente mostra come appare l’indicatore di stop di Chande Kroll.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672905445Chande 1.png" alt=""><br>Chande Kroll Stop- Indicatori di lucertola</p>
<h2 id="h2-Come20calcolare20lindicatore20di20stop20Chande20Kroll358255"><a name="Come calcolare l’indicatore di stop Chande Kroll" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come calcolare l’indicatore di stop Chande Kroll</h2><p>I punti di stop sono derivati dai range massimi e minimi dell’indicatore che vengono confrontati con le perdite medie di arresto dell’asset. Utilizziamo le seguenti formule:</p>
<p>High Stop = Massimo (N) x <em> Intervallo Medio Reale (N)<br>Low Stop = Minimo (N) + x </em> Intervallo Medio Reale (N)</p>
<p>Tuttavia, non è necessario che il trader effettui questi calcoli poiché la maggior parte delle piattaforme di trading dispone di software che lo calcolano.</p>
<p>Nella maggior parte dei casi, però, i trader dovrebbero impostare le tre variabili P, Q e X.</p>
<p>P rappresenta l’Average True Range il cui periodo predefinito è 10.</p>
<p>Q separa le linee dal prezzo di mercato. L’impostazione predefinita è 9, il che lo rende 9 volte superiore alla volatilità.<br>X rappresenta il tempo medio e separa anche le righe dal prezzo. L’impostazione predefinita è 1.</p>
<h2 id="h2-Come20funziona20la20Chande20Kroll20Stop171018"><a name="Come funziona la Chande Kroll Stop?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come funziona la Chande Kroll Stop?</h2><p>Lo scopo principale del Chande Kroll Stop è proteggere il tuo profitto mantenendo il trade aperto finché il prezzo si muove nella giusta direzione. Indica gli stop-loss per le posizioni corte e lunghe.</p>
<p>L’indicatore ha due linee. Una delle linee indica i livelli di stop-loss e take-profit per le posizioni long, mentre l’altra mostra i livelli di stop loss e take-profit per le posizioni short. Con la maggior parte delle piattaforme di trading, la linea rossa è il livello di stop per le posizioni corte, mentre quella verde è per le posizioni lunghe.</p>
<p>Pertanto, la linea verde o blu viene anche chiamata linea di stop lungo mentre quella rossa viene chiamata linea di stop corto. Fondamentalmente, le due linee seguono le variazioni dei prezzi degli asset e individuano i livelli di stop-loss e take-profit.</p>
<p>Per posizioni lunghe, quando il prezzo aumenta, il livello di stop loss aumenta. Tuttavia, quando il prezzo diminuisce, il livello di stop loss rimane fisso a quel livello. Di conseguenza, i trader non devono continuamente regolare gli stop loss trailing.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672905510Chande 2.png" alt=""><br>Long stop e short stop - Indicatore Lizard</p>
<h2 id="h2-Come20usare20lindicatore20Chande20Kroll20Stop116152"><a name="Come usare l’indicatore Chande Kroll Stop" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Come usare l’indicatore Chande Kroll Stop</h2><p>Il Chande Kroll aiuta i trader a identificare i punti di ingresso e di uscita dal trading. Fondamentalmente, i trader possono aprire posizioni di trading quando il prezzo dell’asset è inferiore o superiore a entrambe le linee dell’indicatore.</p>
<p>Ad esempio, l’indicatore genera un segnale di acquisto quando la linea verde o blu attraversa la linea rossa dall’alto. In questo caso, il prezzo dovrebbe trovarsi al di sopra della linea di tendenza. Ciò indica una tendenza al rialzo imminente. Pertanto, una volta ottenute le conferme, i trader possono aprire posizioni long. Si noti che il punto di stop si trova al livello più alto raggiunto dalla linea blu o verde.</p>
<p>Al contrario, l’indicatore genera un segnale di vendita quando la linea rossa attraversa al di sotto della linea blu o verde. In questo caso, il prezzo dovrebbe trovarsi al di sotto della linea di tendenza. È anche importante notare che il punto più basso raggiunto dalla linea rossa funge da livello di stop-loss.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1672905587Chande 3.png" alt=""><br>Segnale di acquisto e segnale di vendita - indicatorspot</p>
<p>Nel diagramma sopra, possiamo osservare la linea blu che attraversa sopra la linea rossa, che è un segnale di acquisto. Vediamo anche la linea rossa che attraversa al di sotto della linea verde o blu, che è un segnale di vendita.</p>
<h2 id="h2-Divergenza20rialzista905830"><a name="Divergenza rialzista" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Divergenza rialzista</h2><p>Una divergenza rialzista può verificarsi anche sull’indicatore di stop di Chande Kroll. Questo avviene quando la linea rossa attraversa al di sotto della linea verde e la attraversa di nuovo al di sopra di essa.</p>
<h2 id="h2-Identificazione20del20trend911366"><a name="Identificazione del trend" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Identificazione del trend</h2><p>Alcuni trader utilizzano l’indicatore Chande Kroll Stop per identificare le inversioni di tendenza. Quando la linea verde o blu attraversa sopra la linea rossa, è un segnale di inversione al rialzo del prezzo. D’altra parte, se la linea rossa attraversa sotto la linea verde o blu, indica un’imminente inversione al ribasso del prezzo.</p>
<h2 id="h2-Conclusione97326"><a name="Conclusione" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusione</h2><p>L’indicatore Chande Kroll Stop è composto da due linee, una linea blu o verde e una rossa. Questo indicatore utilizza calcoli simili a quelli utilizzati per indicare i livelli di stop loss e take profit automatici. Tuttavia, è importante utilizzare il Chande Kroll Stop con altri indicatori tecnici come RSI e MACD.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce suggerimenti di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il ripostaggio dell'articolo a condizione che si faccia riferimento a Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione del copyright.<br></div><p></p><br></div></div></div>