Documentazione

Riferimento di Deepwick Script

Deepwick Script è il linguaggio dei grafici e dei backtest di Deepwick. Esegue un sottoinsieme di Pine Script: la maggior parte delle funzioni ta.*, math.*, str.*, input.*, plot* e strategy.* funziona esattamente come in Pine, e le righe non supportate vengono segnalate con riga e colonna. Questa pagina raccoglie tutto ciò che il motore supporta oggi e ciò che non supporta.

Prima volta su Deepwick? Inizia dalla guida passo a passo: Come fare il backtest di una strategia Pine Script gratis.

Stai costruendo un'IA che scrive Deepwick Script? Questo riferimento in un unico documento Markdown.

Aggiornato: 2026-10-03

Linguaggio

Deepwick Script esegue un sottoinsieme di Pine Script, compresi enum, tipi definiti dall'utente, metodi e map; la riga //@version non viene controllata. Uno script viene eseguito una volta per barra, dalla più vecchia alla più recente, e ogni variabile conserva il suo storico.

Sintassi	Cosa fa
`x = expr / x := expr`	Dichiara una variabile e poi la riassegna con :=. Davanti al nome può precedere un tipo facoltativo (int, float, bool, string, color, series, simple, const, line, label).
`var / varip`	Si inizializza una sola volta sulla prima barra e conserva il valore da una barra all'altra. varip si comporta come var, perché gli script girano su barre chiuse.
`x[n]`	Operatore di storico: il valore di x di n barre fa (na prima della prima barra).
`if / else`	Blocchi condizionali, con rientro di quattro spazi. if si può usare anche come espressione.
`cond ? a : b`	Operatore ternario.
`switch`	Ramificazione multipla, con o senza un valore da confrontare.
`for i = a to b [by step]`	Loop con contatore. break e continue sono supportati.
`while cond`	Loop finché una condizione resta vera.
`f(x, y) => expr`	Funzione definita dall'utente, su una riga o come blocco rientrato la cui ultima espressione viene restituita. Ogni punto di chiamata conserva il proprio stato ta.*, come in Pine.
`[a, b] = f()`	Tuple: le funzioni possono restituire più valori, e lo fanno anche le native come ta.macd() e ta.bb().
`and / or / not`	Operatori logici. Aritmetica: + - * / %; confronto: == != < <= > >=.

Dichiarazioni

Sintassi	Cosa fa
`indicator(title, shorttitle, overlay, precision)`	Dichiara un indicatore: disegna sul grafico e non ha nulla da testare. study() è accettato come alias.
`strategy(title, overlay, initial_capital, default_qty_type, default_qty_value, commission_type, commission_value, slippage, pyramiding)`	Dichiara una strategia. Predefiniti: initial_capital 100000, 1 contratto per ordine, commissione 0, slippage 0 tick, pyramiding 1. Gli altri argomenti, come process_orders_on_close, vengono ignorati.

Ingressi

Gli ingressi compaiono accanto all'editor e nelle impostazioni dell'indicatore, così puoi cambiarli senza toccare il codice.

Sintassi	Cosa fa
`input.int(defval, title, minval, maxval, step)`	Numero intero.
`input.float(defval, title, minval, maxval, step)`	Numero decimale.
`input.bool(defval, title)`	Casella di controllo.
`input.string(defval, title, options)`	Testo, o un elenco di opzioni.
`input.session(defval, title)`	Una sessione di trading come "0930-1600", o giorni come "23456". Passala a session.ismarket() e agli altri predicati session.*.
`input.source(defval, title)`	Una fonte di prezzo: open, high, low, close, hl2, hlc3, ohlc4 o hlcc4.
`input.color(defval, title)`	Selettore di colore.
`input(defval, title)`	Ingresso generico; il tipo segue il valore predefinito.

Dati e tempo della barra

I tempi sono millisecondi UTC. hour() e le altre funzioni di tempo accettano un tempo facoltativo; hour() accetta anche un fuso orario da un elenco fisso di scostamenti, senza l'ora legale.

Sintassi	Cosa fa
`open, high, low, close, volume`	Prezzi e volume della barra corrente.
`hl2, hlc3, ohlc4, hlcc4`	Medie di prezzo usuali.
`bar_index, last_bar_index`	Indice della barra corrente (0 è la più vecchia) e dell'ultima barra.
`time, time_close`	Ora di apertura e di chiusura della barra. Come funzioni — time("D"), time(timeframe.period, "0000-0900:23456", "UTC") — l'inizio (o la fine) della barra di temporalità superiore che la contiene, o na quando la barra è fuori sessione. Sessioni: "HHMM-HHMM", anche notturne, più finestre separate da virgole, giorni facoltativi dopo i due punti (1 = domenica … 7 = sabato), "24x7".
`timeframe.change(timeframe)`	Vero sulla prima barra di ogni nuovo periodo, ad es. timeframe.change("D") sulla prima barra di ogni giorno (le settimane iniziano il lunedì).
`timestamp(timezone?, year, month, day, hour, minute, second)`	Un tempo in millisecondi dalle sue parti, o da una data in testo: timestamp("2026-01-05T09:30:00Z").
`dayofweek.sunday … dayofweek.saturday`	Costanti di giorno da confrontare con dayofweek (1 … 7).
`session.ismarket, isfirstbar, islastbar, ispremarket, ispostmarket`	Stato della sessione. Qui i mercati negoziano pressoché senza sosta, quindi ogni barra è in sessione; isfirstbar / islastbar segnano la prima e l'ultima barra di ogni giorno UTC.
`year, month, weekofyear, dayofmonth, dayofweek, hour, minute, second`	Parti di calendario dell'ora della barra; chiamabili anche con un tempo, ad es. hour(time, "America/New_York"). dayofweek: 1 = domenica … 7 = sabato.
`barstate.isfirst, islast, isnew, isconfirmed, ishistory, isrealtime`	Dove si trova lo script nella storia delle barre.
`timeframe.period, multiplier, isintraday, isdaily, isweekly, ismonthly`	La temporalità del grafico.
`syminfo.ticker, tickerid, mintick, pointvalue`	Il simbolo del grafico, il suo passo di prezzo e il suo valore del punto.

Analisi tecnica (ta.*)

Ogni punto di chiamata conserva il proprio stato, come in Pine: due chiamate ta.ema() su righe diverse sono due medie indipendenti. Il risultato è na finché non ci sono barre sufficienti.

Sintassi	Cosa fa
`ta.sma(source, length)`	Media mobile semplice.
`ta.ema(source, length)`	Media mobile esponenziale.
`ta.rma(source, length)`	Media mobile di Wilder, usata da RSI e ATR.
`ta.wma(source, length)`	Media mobile ponderata.
`ta.vwma(source, length)`	Media mobile ponderata sul volume.
`ta.hma(source, length)`	Media mobile di Hull.
`ta.linreg(source, length, offset)`	Valore della retta di regressione lineare.
`ta.vwap(source)`	Prezzo medio ponderato sul volume, che riparte alle 00:00 UTC di ogni giorno.
`ta.rsi(source, length)`	Indice di forza relativa, da 0 a 100.
`ta.macd(source, fastlen, slowlen, siglen)`	Restituisce [macd, signal, histogram].
`ta.stoch(source, high, low, length)`	Stochastic %K, da 0 a 100.
`ta.cci(source, length)`	Commodity Channel Index.
`ta.mfi(series, length)`	Money Flow Index.
`ta.wpr(length)`	Williams %R, da -100 a 0.
`ta.dmi(diLength, adxSmoothing)`	Restituisce [+DI, -DI, ADX].
`ta.supertrend(factor, atrPeriod)`	Restituisce [supertrend, direction]; la direzione è -1 in un rialzo e 1 in un ribasso.
`ta.sar(start, inc, max)`	SAR parabolico.
`ta.mom(source, length)`	Momentum: la fonte meno la fonte di length barre fa.
`ta.roc(source, length)`	Variazione percentuale, in percentuale.
`ta.change(source, length)`	Differenza rispetto a length barre fa (1 per predefinito).
`ta.tr / ta.tr(handle_na)`	True range.
`ta.atr(length)`	Average true range (Wilder).
`ta.bb(series, length, mult)`	Bande di Bollinger: restituisce [middle, upper, lower].
`ta.bbw(series, length, mult)`	Ampiezza delle bande di Bollinger: (upper - lower) / middle.
`ta.kc(series, length, mult)`	Canali di Keltner: restituisce [middle, upper, lower], con una media esponenziale del true range.
`ta.stdev(source, length, biased)`	Deviazione standard.
`ta.variance(source, length, biased)`	Varianza.
`ta.dev(source, length)`	Scarto medio assoluto.
`ta.median(source, length)`	Mediana.
`ta.highest(source, length) / ta.highest(length)`	Valore massimo sulle ultime length barre (il high per predefinito).
`ta.lowest(source, length) / ta.lowest(length)`	Valore minimo sulle ultime length barre (il low per predefinito).
`ta.highestbars(source, length)`	Scostamento rispetto al valore massimo: 0 o negativo.
`ta.lowestbars(source, length)`	Scostamento rispetto al valore minimo: 0 o negativo.
`ta.rising(source, length)`	Vero se la fonte è sopra ognuno dei suoi length valori precedenti.
`ta.falling(source, length)`	Vero se la fonte è sotto ognuno dei suoi length valori precedenti.
`ta.crossover(source1, source2)`	Vero sulla barra in cui source1 incrocia sopra source2.
`ta.crossunder(source1, source2)`	Vero sulla barra in cui source1 incrocia sotto source2.
`ta.cross(source1, source2)`	Vero su un incrocio in entrambe le direzioni.
`ta.pivothigh(source, leftbars, rightbars)`	Il prezzo del pivot high, noto rightbars barre dopo il pivot; na altrimenti. La fonte è facoltativa (il high per predefinito).
`ta.pivotlow(source, leftbars, rightbars)`	Il prezzo del pivot low, noto rightbars barre dopo il pivot; na altrimenti. La fonte è facoltativa (il low per predefinito).
`ta.valuewhen(condition, source, occurrence)`	Valore della fonte sulla occurrence-esima barra più recente in cui la condizione era vera.
`ta.barssince(condition)`	Barre da quando la condizione è stata vera l'ultima volta.
`ta.cum(source)`	Totale cumulato dalla prima barra.

Altre temporalità (request.*)

Una temporalità superiore è costruita a partire dalle barre del grafico stesso, quindi non ha bisogno di dati che il motore non ha. Il valore di una barra di temporalità superiore diventa visibile solo sulla barra del grafico DOPO che si è chiusa: una barra da 4h non è mai leggibile da dentro sé stessa, ed è questo che mantiene onesto un backtest.

Sintassi Cosa fa

request.security(symbol, timeframe, expression) Esegue expression su una temporalità superiore dello STESSO simbolo e restituisce l'ultimo valore CHIUSO. Funziona sul simbolo del grafico stesso (o syminfo.tickerid, o un simbolo vuoto); un altro simbolo restituisce na, perché il motore detiene solo le barre del grafico. Le temporalità accettano la notazione di Pine ("60", "240", "D", "W", "M") e quella di Deepwick ("1h", "4h", "1d"). L'espressione può essere una chiamata ta.*, valutata sulla serie della temporalità superiore. Restituisce na finché una di queste barre non si è chiusa.

request.security(..., lookahead) Accettato e ignorato. lookahead_on permetterebbe a un backtest di leggere la barra di temporalità superiore in formazione, e quello è guardare il futuro; il motore non sbircia mai. gaps riguarda solo il disegno dentro la barra, che qui non si applica.

Sintassi	Cosa fa
`request.security(symbol, timeframe, expression)`	Esegue expression su una temporalità superiore dello STESSO simbolo e restituisce l'ultimo valore CHIUSO. Funziona sul simbolo del grafico stesso (o syminfo.tickerid, o un simbolo vuoto); un altro simbolo restituisce na, perché il motore detiene solo le barre del grafico. Le temporalità accettano la notazione di Pine ("60", "240", "D", "W", "M") e quella di Deepwick ("1h", "4h", "1d"). L'espressione può essere una chiamata ta.*, valutata sulla serie della temporalità superiore. Restituisce na finché una di queste barre non si è chiusa.
`request.security(..., lookahead)`	Accettato e ignorato. lookahead_on permetterebbe a un backtest di leggere la barra di temporalità superiore in formazione, e quello è guardare il futuro; il motore non sbircia mai. gaps riguarda solo il disegno dentro la barra, che qui non si applica.

Strategie (strategy.*)

Gli ordini a mercato vengono eseguiti all'apertura della barra successiva. Stop e limit si eseguono lungo la barra: apertura, poi l'estremo più vicino all'apertura, poi l'altro estremo, poi la chiusura. Se il prezzo apre un gap attraverso un ordine, l'ordine viene eseguito all'apertura. La commissione è addebitata a ogni esecuzione; lo slippage vale per le esecuzioni a mercato e stop.

Sintassi	Cosa fa
`strategy.entry(id, direction, qty, limit, stop, comment)`	Apre o aumenta una posizione; ordine a mercato se non sono indicati limit o stop.
`strategy.order(id, direction, qty, limit, stop, comment)`	Gli stessi argomenti di strategy.entry().
`strategy.exit(id, from_entry, qty_percent, profit, limit, loss, stop, trail_points, trail_offset, comment)`	Take-profit, stop-loss e trailing stop di un ingresso: profitto e perdita in tick, limit e stop come prezzi. trail_points è la distanza in TICK dal miglior prezzo raggiunto; trail_offset è il profitto in tick che va ripulito prima che il trailing stop si armi. Lo stop scatta solo a tuo favore e si muove su barre CHIUSE, così una barra non può mai eseguire lo stop che il suo stesso massimo ha impostato.
`strategy.close(id, comment, qty_percent)`	Chiude un ingresso a mercato alla barra successiva.
`strategy.close_all(comment)`	Chiude tutte le posizioni aperte.
`strategy.cancel(id) / strategy.cancel_all()`	Annulla gli ordini in attesa.
`strategy.position_size, position_avg_price`	Posizione attuale (positiva long, negativa short) e il suo prezzo medio.
`strategy.opentrades.entry_bar_index(n), entry_price, entry_time, entry_id, size, profit, commission, max_runup, max_drawdown`	Dettagli dell'operazione aperta n (0 = la più vecchia); na se non esiste. size è negativo sulle short. Es. uscire dopo 10 barre: bar_index - strategy.opentrades.entry_bar_index(0) >= 10.
`strategy.closedtrades.entry_bar_index(n), exit_bar_index, entry_price, exit_price, entry_time, exit_time, entry_id, size, profit, commission, max_runup, max_drawdown`	Dettagli dell'operazione chiusa n (0 = la più vecchia; l'ultima è strategy.closedtrades - 1).
`strategy.equity, netprofit, openprofit, grossprofit, grossloss, initial_capital`	Numeri del conto.
`strategy.closedtrades, opentrades, wintrades, losstrades`	Conteggi delle operazioni.
`strategy.long, strategy.short`	Direzioni.
`strategy.fixed, strategy.cash, strategy.percent_of_equity`	Valori per default_qty_type.
`strategy.commission.percent, cash_per_order, cash_per_contract`	Valori per commission_type.

Grafici e avvisi

Sintassi	Cosa fa
`plot(series, title, color, linewidth, style)`	Disegna una serie sul grafico o in un riquadro.
`plotshape(series, title, style, location, color, text)`	Disegna una forma sulle barre in cui series è vera.
`plotchar(series, title, char, location, color)`	Disegna un carattere sulle barre in cui series è vera.
`hline(price, title, color, linestyle)`	Linea orizzontale a un livello fisso.
`fill(plot1, plot2, color)`	Riempie tra due grafici o due hlines.
`bgcolor(color)`	Colora lo sfondo della barra.
`barcolor(color)`	Colora la barra stessa.
`alertcondition(condition, title, message)`	Dichiara una condizione che puoi trasformare in un avviso via email, Telegram, Discord o webhook.
`plot.style_*`	line, linebr, stepline, histogram, columns, circles, cross, area.
`hline.style_*`	solid, dashed, dotted.
`shape.*`	triangleup, triangledown, arrowup, arrowdown, circle, xcross, cross, diamond, square, flag, labelup, labeldown.
`location.*`	abovebar, belowbar, top, bottom, absolute.
`size.*`	auto, tiny, small, normal, large, huge. Accettato, ma le forme vengono disegnate tutte della stessa dimensione.

Linee e riquadri

Sintassi	Cosa fa
`line.new(x1, y1, x2, y2, extend, color, style, width)`	Disegna una linea tra due indici di barra e due prezzi; restituisce il suo id.
`line.set_x1, set_y1, set_x2, set_y2, set_xy1, set_xy2, set_color, set_style, set_width`	Modifica una linea.
`line.delete(id)`	Rimuove una linea.
`box.new(left, top, right, bottom, border_color, bgcolor, extend)`	Disegna un rettangolo; restituisce il suo id.
`box.set_left, set_top, set_right, set_bottom, set_bgcolor, set_border_color, set_extend`	Modifica un riquadro.
`box.delete(id)`	Rimuove un riquadro.
`line.style_, box.style_`	solid, dashed, dotted.
`extend.*`	none, left, right, both.

Matematica, stringhe e colori

Sintassi	Cosa fa
`math.abs, ceil, floor, round(number, precision), sign, sqrt, exp, log, log10, pow(base, exponent)`	Aritmetica.
`math.max(...), math.min(...), math.avg(...)`	Su un numero qualsiasi di valori.
`math.sum(source, length)`	Somma sulle ultime length barre.
`math.pi, math.e`	Costanti.
`na, na(x), nz(x, replacement), fixnan(x)`	Il valore mancante, un test per esso, una sostituzione e l'ultimo valore non-na.
`int(x), float(x), bool(x)`	Conversioni.
`str.tostring(value, format), str.format(text, ...), str.length(s), str.contains(s, part)`	Stringhe. str.format sostituisce {0}, {1}… con gli argomenti.
`color.new(color, transp), color.rgb(red, green, blue, transp)`	Costruisce un colore; la trasparenza va da 0 a 100.
`color.*`	red, green, blue, orange, yellow, purple, aqua, lime, fuchsia, teal, maroon, navy, olive, gray, silver, white, black.

Array (array.*)

Sintassi	Cosa fa
`array.new_float, new_int, new_bool, new_string, new_color, new_line, new_box, new_label, new_table(size)`	Crea un array.
`array.get, set, insert, push, pop, shift, unshift`	Legge e modifica gli elementi.
`array.size, first, last, sum, avg, min, max, stdev`	Dimensione e statistiche.

Map e tipi definiti dall'utente

I tipi definiti dall'utente e la collezione `map.<fn>` sono supportati. Entrambi sono dichiarazioni di primo livello; i metodi di istanza su un valore usano la sintassi `obj.method(args...)`.

Sintassi	Cosa fa
`enum Name Member Member = N ...`	Dichiarazione di enum di primo livello. I membri senza valore si incrementano da soli da 0; i valori espliciti possono essere numeri o stringhe. Si accede come `Name.Member` in qualsiasi posizione di espressione. I valori di enum sono numeri (o stringhe) semplici, quindi funzionano con gli operatori di confronto e con `int()` senza conversione.
`type Name field1 field2: int field3 = default`	Tipo definito dall'utente, di primo livello. I campi si elencano uno per riga; le parti `: type` e `= default` sono accettate per compatibilità futura ma non sono ancora validate. Si costruisce con `Type.new(arg1, arg2, ...)` e i campi si leggono con `instance.field`.
`m = map.new<int, float>()`	Crea una map vuota. Gli argomenti di tipo `<K, V>` sono accettati ma ignorati a runtime.
`m = map.put(m, key, value)`	Imposta una chiave. Restituisce la map, così le chiamate possono essere concatenate o riassegnate.
`v = map.get(m, key)`	Legge un valore. Restituisce na se la chiave non c'è.
`n = map.size(m)`	Numero di voci.
`keys = map.keys(m), values = map.values(m)`	Restituisce le chiavi o i valori come array di Pine (ordine di inserimento).
`map.contains(m, key), map.remove(m, key)`	Test di appartenenza e cancellazione. Entrambi restituiscono la map.

Non ancora supportato

Una funzione che il motore non conosce ferma lo script con «Unknown function» e la riga e la colonna.

Sintassi	Cosa fa
`label.new(), table.new()`	Non ancora disponibile. Linee e riquadri sì.
`import, matrix.*, array.new<type>()`	Librerie, matrici e costruttori di array tipati non sono ancora implementati.
`strategy.risk.*`	Le regole di rischio (max_position_size, max_intraday_loss, max_drawdown, allow_entry_in) non sono supportate. I trailing stop in strategy.exit() sì: usa trail_points e trail_offset.

Domande

Deepwick Script è la stessa cosa di Pine Script?

No. È il motore proprietario di Deepwick, che esegue un sottoinsieme di Pine Script: le funzioni di questa pagina. La maggior parte delle chiamate ta.*, math.*, str.*, input.*, plot* e strategy.* gira così com'è; le righe non supportate vengono segnalate con riga e colonna. Deepwick non è affiliata a TradingView; Pine Script è un marchio di TradingView, Inc.

Quali funzionalità di Pine Script supporta Deepwick Script?

Deepwick Script esegue un sottoinsieme di Pine Script, compresi enum, tipi definiti dall'utente (`type`), dichiarazioni di metodi e la collezione `map.*`. Non ancora implementati: le librerie (`import`), `matrix.*` e i costruttori di array tipati `array.new<type>()`; l'editor li segnala con la riga e la colonna esatte. La riga //@version non viene controllata. Incolla uno script nell'editor per vedere quali righe girano.

Deepwick supporta request.security()?

Sì, per una temporalità superiore del simbolo del grafico stesso. request.security(syminfo.tickerid, "240", close) restituisce l'ultimo close 4h CHIUSO, e l'espressione può essere una chiamata ta.*. Un altro simbolo restituisce comunque na: il motore detiene solo le barre del grafico, e un numero plausibile ma sbagliato sarebbe peggio di nessuno.

Perché request.security() restituisce na sulle prime barre?

Perché non è ancora chiusa nessuna barra di temporalità superiore. Una barra da 4h diventa leggibile solo sulla barra del grafico successiva alla sua chiusura, ed è esattamente questo che impedisce a un backtest di leggere una barra ancora in formazione. Una volta chiusa, il valore si ripete finché non si chiude la successiva.

Come vengono eseguiti gli ordini di una strategia in un backtest?

Gli ordini a mercato vengono eseguiti all'apertura della barra successiva. Stop e limit si eseguono lungo la barra (apertura, estremo più vicino, estremo più lontano, chiusura), e un ordine che il prezzo scavalca con un gap viene eseguito all'apertura. La commissione è addebitata a ogni esecuzione e lo slippage sulle esecuzioni a mercato e stop, come impostato in strategy(); entrambi valgono zero per predefinito.

Dove girano gli script?

Sul grafico, nel tuo browser, sulle barre caricate nel grafico. I backtest salvati girano sui server di Deepwick su fino a 5.000 barre.