[TOC]

Từ khóa, ngữ pháp, thiết lập bản tóm tắt

Cấu trúc mã

Các cấu trúc chung của mã trong Pine:

<version>
<declaration_statement>
<code>

Phản hồi

FMZ hỗ trợ các ký hiệu chú thích ngôn ngữ Pine: một dòng chú thích//Các dòng chú thích/* */Ví dụ như cách viết chú thích trong ví dụ sau:

[macdLine, signalLine, histLine] = ta.macd(close, 12, 26, 9)  // 计算MACD指标

/*
plot函数在图表上画出指标线
*/
plot(macdLine, color = color.blue, title='macdLine')
plot(signalLine, color = color.orange, title='signalLine')
plot(histLine, color = color.red, title='histLine')

Phiên bản

Các hướng dẫn trình biên dịch dưới dạng sau đây cho phép trình biên dịch biết phiên bản nào của kịch bản được viết bằng Pine:

//@version=5

Mặc định là phiên bản v5, có thể bỏ qua trong mã//@version=5。

Lời tuyên bố

• indicator()
• strategy()

Các tuyên bố xác định loại kịch bản, điều này cũng quyết định nội dung nào được cho phép trong đó, và cách sử dụng và thực hiện. Thiết lập các thuộc tính quan trọng của kịch bản, chẳng hạn như tên của nó, nơi nó sẽ xuất hiện khi nó được thêm vào biểu đồ, độ chính xác và định dạng của các giá trị nó hiển thị, và kiểm soát một số giá trị hành vi của nó khi chạy, chẳng hạn như số lượng đối tượng vẽ tối đa mà nó sẽ hiển thị trên biểu đồ. Đối với các chính sách, thuộc tính bao gồm các tham số kiểm soát xem lại, chẳng hạn như vốn ban đầu, hoa hồng, điểm trượt, vv.indicator()Hoặcstrategy()Những lời tuyên bố.

Mã

Các dòng không phải là chú thích hoặc hướng dẫn trình biên dịch trong kịch bản là câu nói, nó thực hiện các thuật toán của kịch bản. Một câu nói có thể là một trong số đó.

• Tuyên bố biến
• Đặt lại giá trị của biến
• Tuyên bố hàm
• Gọi hàm tích hợp, gọi hàm được xác định bởi người dùng
• if，for，whileHoặcswitchcấu trúc tương tự

Câu nói có thể được sắp xếp theo nhiều cách

• Một số câu nói có thể được thể hiện bằng một dòng, chẳng hạn như hầu hết các tuyên bố biến, chỉ chứa một dòng gọi hàm hoặc một dòng tuyên bố hàm; những câu khác, như cấu trúc, luôn cần nhiều dòng vì chúng cần một khối địa phương.
• Các câu nói toàn cầu của kịch bản (tức là những phần không thuộc về các phần) không thể được sử dụng để viết một câu nói toàn cầu.空格Hoặc制表符(tab key) bắt đầu. Chữ ký tự đầu tiên của chúng cũng phải là ký tự đầu tiên của dòng. Các dòng bắt đầu ở vị trí đầu tiên của dòng, theo định nghĩa là một phần của phạm vi toàn cầu của kịch bản.
• Một cấu trúc hoặc một tuyên bố chức năng nhiều dòng luôn cần mộtlocal blockMột khối địa phương phải được thu hẹp thành một biểu mẫu hoặc bốn không gian (nếu không, nó sẽ được phân tích thành dòng mã chuỗi trước đó, nghĩa là được xác định là nội dung liên tục của dòng mã trước đó), và mỗi khối địa phương xác định một phạm vi địa phương khác.
• Nhiều câu đơn hàng có thể được nối liền trong một dòng bằng cách sử dụng dấu chấm (,) làm dấu phân cách.
• Một dòng có thể bao gồm chú thích hoặc chỉ là chú thích.
• Dòng cũng có thể được gói lại (tiếp tục trên nhiều dòng).

Ví dụ, bao gồm ba phần tử, một trong tuyên bố chức năng tùy chỉnh, hai trong tuyên bố biến sử dụng cấu trúc if, mã như sau:

indicator("", "", true)             // 声明语句(全局范围)，可以省略不写

barIsUp() =>                        // 函数声明(全局范围)
    close > open                    // 本地块(本地范围)

plotColor = if barIsUp()            // 变量声明 (全局范围)
    color.green                     // 本地块 (本地范围)
else
    color.red                       // 本地块 (本地范围)

runtime.log("color", color = plotColor)  // 调用一个内置函数输出日志 (全局范围)

Đổi mã

Dòng dài có thể được chia thành nhiều dòng, hoặc được gói gọn gọn. Dòng được gói gọn phải thu hẹp bất kỳ số lượng không gian nào, miễn là nó không phải là số lần của 4 (các ranh giới này được sử dụng để thu hẹp các phần tử).

a = open + high + low + close

Có thể được đóng gói như sau (lưu ý rằng không có số lượng không gian co lại cho mỗi dòng là số lần của 4):

a = open +
      high +
          low +
             close

Một cuộc gọi dài có thể được đóng gói thành một cuộc gọi dài.

close1 = request.security(syminfo.tickerid, "D", close)      // syminfo.tickerid 当前交易对的日线级别收盘价数据系列
close2 = request.security(syminfo.tickerid, "240", close)    // syminfo.tickerid 当前交易对的240分钟级别收盘价数据系列
plot(ta.correlation(close, open, 100),                       // 一行长的plot()调用可以被包装
   color = color.new(color.purple, 40),
   style = plot.style_area,
   trackprice = true)

Một câu nói trong một tuyên bố chức năng được xác định bởi người dùng cũng có thể được đóng gói. Tuy nhiên, vì một phần tử địa phương phải bắt đầu bằng cách rút ngắn (tương đương 4 không gian hoặc 1 ký tự), khi chia nó sang dòng tiếp theo, phần tiếp theo của câu nói phải bắt đầu bằng nhiều hơn một lần rút ngắn (không bằng số lần của 4 không gian). Ví dụ:

test(c, o) =>
    ret = c > o ?
       (c > o+5000 ? 
          1 :
              0):
       (c < o-5000 ? 
          -1 : 
              0)

a = test(close, open)
plot(a, title="a")

Dòng thời gian

Không phải là một kiểu dữ liệu hoặc định dạng, chuỗi thời gian là một khái niệm cơ bản trong ngôn ngữ PINE. Nó được sử dụng để lưu trữ các giá trị liên tục thay đổi theo thời gian, mỗi giá trị tương ứng với một điểm thời gian. Các biến tích hợpopenVí dụ:openCác biến cố tích hợp ghi lại giá mở của mỗi dòng KBAR, nếuopenDữ liệu của 5 phút K-line cycle.openNhững gì được ghi lại trong biến là giá mở cửa của mỗi 5 phút K-line BAR (cột). Khi chương trình chính sách của bạn đang được thực hiện, tham chiếu trong mãopenĐó là giá mở cửa của dòng K BAR ở vị trí hiện tại. Để tham khảo giá trị trước trong chuỗi thời gian, chúng ta sử dụng giá trị quá khứ.[]Chế toán lịch sử, khi một chính sách được thực hiện trên một K-line BARopen[1]Có nghĩa là tham khảo giá mở đầu của một K-Line BAR trước đó của dòng K hiện tại.

Mặc dùDòng thời gianMột cấu trúc dữ liệu dễ dàng gợi nhớ đến "các mảng", mặc dù ngôn ngữ PINE cũng có loại mảng. Nhưng chúng là một khái niệm hoàn toàn khác với chuỗi thời gian.

Các chuỗi thời gian được thiết kế như vậy trong ngôn ngữ PINE có thể dễ dàng tính toán giá trị tổng hợp của giá đóng cửa trong mã chính sách mà không cần sử dụng cấu trúc vòng lặp như for, chỉ sử dụng các hàm tích hợp của ngôn ngữ PINE.ta.cum(close)Một ví dụ khác, chúng ta cần tính toán giá trị trung bình của giá trị tối đa và chênh lệch giá trị tối thiểu của 14 dòng K cuối cùng BAR (tức là 14 dòng K gần nhất đến thời điểm thực hiện mã) có thể được viết như sau:ta.sma(high - low, 14)

Kết quả của việc gọi hàm trên chuỗi thời gian cũng sẽ có dấu vết trên chuỗi thời gian, cũng có thể được sử dụng[]Các toán tử lịch sử đề cập đến các giá trị trước đó. Ví dụ, để kiểm tra giá đóng cửa của dòng K BAR hiện tại có vượt quá giá tối đa của giá cao nhất trong 10 dòng K BAR cuối cùng (không bao gồm dòng K BAR hiện tại)? Chúng ta có thể viết làbreach = close > ta.highest(close, 10)[1]Và cũng có thể viết như sau:breach = close > ta.highest(close[1], 10)Vì vậy.ta.highest(close, 10)[1]vàta.highest(close[1], 10)Có một số người nói rằng:

Bạn có thể xác minh bằng mã sau:

strategy("test pine", "test", true) 

a = ta.highest(close, 10)[1]
b = ta.highest(close[1], 10)

plotchar(true, title="a", char=str.tostring(a), location=location.abovebar, color=color.red)
plotchar(true, title="b", char=str.tostring(b), location=location.belowbar, color=color.green)

Mã kiểm tra trên sẽ xuất ra giá trị của a và b trên chuỗi thời gian tương ứng của chúng trên mỗi BAR, bạn có thể thấy giá trị của a và b luôn bằng nhau, vì vậy cả hai phương pháp biểu diễn đều tương đương.

Các tham số mẫu thư viện giao dịch ngôn ngữ Pine

Phương pháp xây dựng mô hình của chính sách PINE "Pine language transaction library"

Thiết lập giao dịch

• Cách thực hiện Mô hình giá đóng cửa: Mô hình chỉ được thực hiện sau khi BAR hiện tại kết thúc, thực hiện giao dịch khi BAR dưới bắt đầu. Mô hình giá thời gian thực: Mô hình được thực hiện mỗi khi giá thay đổi, có tín hiệu thực hiện giao dịch ngay lập tức.
• Số lượng giao dịch mặc định: Nếu lệnh giao dịch không chỉ định số lượng giao dịch, giao dịch sẽ được thực hiện theo số lượng đó.
• Số lượng đặt hàng tối đa một lần: Theo giao dịch thực tế, kết hợp với cài đặt tham số này, xác định số lượng đặt hàng tối đa mỗi lần, tránh tác động đến mặt bàn.
• Số điểm giá trượt:定价货币精度Các tham số và tham số này xác định giá trượt khi đặt hàng; ví dụ, đặt giá chính xác tiền tệ là 2 chính xác đến vị trí thứ hai của số nhỏ, chính xác đến 0.01; sau đó, số điểm trượt cho mỗi điểm đại diện cho 0.01 đơn vị định giá. Tại đây, đặt số điểm trượt là 5, giá trượt khi đặt hàng là 0.05 ((giá trượt chỉ số khi đặt hàng để tốt hơn và thanh toán phần giá quá mức giao dịch).
• Số chu kỳ dài nhất của biến: ảnh hưởng đến số lượng BAR của đường K trên biểu đồ, vớijavascriptGọi trong chiến lượcSetMaxBarLenChức năng tương tự.

Các lựa chọn tương lai

• Mã giống: Mã hợp đồng, chỉ cần thiết lập khi đối tượng giao dịch là đối tượng giao dịch không trực tiếp.
• Số lượng giao dịch tối thiểu: Số lượng giao dịch tối thiểu khi đặt hàng.

Tùy chọn ổ đĩa thực

• Tự động khôi phục tiến độ: Tự động khôi phục lại trạng thái trước khi chính sách cuối cùng bị dừng.
• Số lần thử lại lệnh: lệnh không giao dịch sẽ hủy lệnh, đặt lại lệnh thử giao dịch, tham số này được sử dụng để giới hạn số lần thử lại tối đa.
• Khoảng thời gian truy vấn mạng (millisecond): Chỉ có hiệu lực đối với giao thức REST, kiểm soát khoảng thời gian yêu cầu mạng, tránh yêu cầu quá thường xuyên, vượt quá giới hạn của sàn giao dịch.
• Thời gian đồng bộ hóa tài khoản: Thời gian đồng bộ hóa dữ liệu tài khoản.
• Thời gian đồng bộ hóa vị trí sau khi bắt đầu giao dịch: chỉ đối với một số giao dịch bị chậm dữ liệu, việc đặt thời gian đồng bộ hóa lớn hơn có thể giảm thiểu các vấn đề như vậy.
• Tỷ lệ đòn bẩy: Đặt tỷ lệ đòn bẩy.

Giao dịch trực tiếp, thiết lập khác

• Số lượng giao dịch một tay: Số lượng giao dịch một tay mặc định, chỉ có hiệu lực đối với hiện tại.
• Số lượng giao dịch nhỏ nhất: Số lượng giao dịch nhỏ nhất.
• Định giá chính xác tiền tệ: chính xác giá, tức là số chữ số nhỏ của giá.
• Độ chính xác của các loại giao dịch: độ chính xác của đơn vị sau, nghĩa là số lượng nhỏ của đơn vị sau.
• Chi phí: tính toán một số dữ liệu theo cài đặt này, 0.002 là 2 phần nghìn.
• Khoảng thời gian thống kê lợi nhuận và lỗ: chỉ sử dụng thống kê lợi nhuận và lỗ trên đĩa thực.
• Thử lại thất bại (millisecond): Khoảng thời gian thử lại khi yêu cầu mạng thất bại.
• Người dùng đại diện: Chỉ có hiệu quả đối với giao thức REST.
• Hide Common Network Errors: Hide Common Error Logs in the Log Area (Tạm dịch: ẩn những lỗi phổ biến trên mạng: ẩn những lỗi phổ biến trong khu vực nhật ký)
• Chuyển địa chỉ cơ sở: Chỉ có hiệu lực đối với giao thức REST.
• Thông báo đẩy: Đẩy tin nhắn đến hộp thư, v.v.

Giao dịch

Mở cửa

strategy(title = "open long example", pyramiding = 3)                                // pyramiding 允许的同方向下单的次数
strategy.entry("long1", strategy.long, 0.01)                                         // 市价开多仓，指定分组标签为long1
strategy.entry("long2", strategy.long, 0.02, when = close > ta.ema(close, 10))       // 条件触发，执行下单，市价开多仓
strategy.entry("long3", strategy.long, 0.03, limit = 30000)                          // 指定（较低的）价格，计划下买单订单，等待成交开仓，限价开仓

Cửa hàng

strategy(title = "close long example", pyramiding = 2)                              // pyramiding 允许的同方向下单的次数
strategy.entry("long1", strategy.long, 0.1)                                         // 市价开多仓，指定分组标签为long1
strategy.entry("long2", strategy.long, 0.1)                                         // 市价开多仓，指定分组标签为long2
strategy.close("long1", when = strategy.position_size > 0.1, qty_percent = 50, comment = "close buy entry for 50%")   // 平仓，指定平掉分组标签为long1的仓位的50%持仓
strategy.close("long2", when = strategy.position_size > 0.1, qty_percent = 80, comment = "close buy entry for 80%")   // 平仓，指定平掉分组标签为long2的仓位的80%持仓

Cơ chế giao dịch

Phương pháp nắm giữ của ngôn ngữ PINE tương tự như nắm giữ một chiều. Ví dụ, khi nắm giữ nhiều vị trí, nếu có lệnh bán, danh sách kế hoạch, v.v. (đối với hướng ngược lại với hướng nắm giữ), lệnh sẽ được kích hoạt trước khi thực hiện lệnh kích hoạt đối với hướng ngược lại với hướng nắm giữ trước khi nắm giữ.

Danh sách kế hoạch

Khi sử dụng lệnh đặt hàng, nếu không chỉ định bất kỳ mức giá nào, mặc định đặt hàng theo giá thị trường. Ngoài giá thị trường, bạn cũng có thể đặt hàng bằng đơn đặt hàng theo kế hoạch, đơn đặt hàng sẽ không hoạt động ngay lập tức.Đĩa thực / kiểm tra lạiThông tin trạng thái thời gian (tức là thanh trạng thái khi chính sách đang chạy) được nhìn thấy trong bảng phân trang "lệnh dự kiến"; hệ thống sẽ thực sự đặt các đơn đặt hàng này khi giá thị trường thực tế đáp ứng các điều kiện kích hoạt các đơn đặt hàng này. Vì vậy, các đơn đặt hàng này có sự chênh lệch nhỏ trong giá giao dịch là điều bình thường. Sử dụngstrategy.entryKhi chúng ta sắp xếp các hàm, chúng ta có thể chỉ địnhlimit、stopCác tham số.

var isTrade = false 
if not barstate.ishistory and not isTrade
    isTrade := true 
    strategy.entry("test 1", strategy.long, 0.1, stop=close*1.3, comment="test 1 order")                     // stop
    strategy.entry("test 2", strategy.long, 0.2, limit=close*0.7, comment="test 2 order")                    // limit
    strategy.entry("test 3", strategy.short, 0.3, stop=close*0.6, limit=close*1.4, comment="test 3 order")   // stop-limit    

• Đặt hàng giới hạn

Đặt giá giới hạn cho đơn đặt hàng, khi đơn đặt hàng là thanh toán (tức làdirectionCác tham số làstrategy.long), chỉ khi giá hiện tại trên thị trường thấp hơn, lệnh sẽ được kích hoạt. Khi đơn đặt hàng là bán hàng (tức làdirectionCác tham số làstrategy.short), chỉ khi giá hiện tại trên thị trường cao hơn, lệnh sẽ được kích hoạt.

• Đặt lệnh dừng

Thiết lập giá dừng lỗ cho lệnh, khi lệnh là mua, lệnh sẽ chỉ được kích hoạt khi giá hiện tại trên thị trường cao hơn giá đó. Khi lệnh bán, lệnh chỉ được kích hoạt khi giá hiện tại trên thị trường thấp hơn giá đó.

• Stop-limit đặt hàng

Có thể được thiết lập cùng một lúclimit、stopCác tham số, các đơn đặt hàng được kích hoạt ở mức giá phù hợp với điều kiện đầu tiên.

Tỷ lệ quyền lợi

//@version=5
strategy("Percent of Equity Order", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=100)  

// 简单的均线交叉策略
longCondition = ta.crossover(ta.sma(close, 14), ta.sma(close, 28))
shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))  

// 如果均线交叉条件满足，则买入或卖出
if (longCondition)
    strategy.entry("Long", strategy.long)  

if (shortCondition)
    strategy.entry("Short", strategy.short)
  

Đặtdefault_qty_type=strategy.percent_of_equitySau đó, cài đặtdefault_qty_valueSố phần trăm ((0 đến 100), 1 là 1%;; số đơn được tính theo số tiền được tính trong tài khoản;; ví dụ: tài khoản hiện tại có 10000 USDT, đặt đơn đặt hàng 1%, tức là sử dụng đơn đặt hàng quy mô 100 USDT (được tính theo giá hiện tại khi bán).

Tuyên bố, từ khóa cấu trúc logic

var

var là từ khóa được sử dụng để phân bổ và khởi tạo một lần các biến. Thông thường, ngữ pháp gán biến mà không bao gồm từ khóa var sẽ dẫn đến việc giá trị của biến sẽ được phủ lên mỗi khi dữ liệu được cập nhật. Ngược lại, khi sử dụng từ khóa var để phân bổ biến, chúng vẫn có thể giữ trạng thái mặc dù dữ liệu được cập nhật, chỉ thay đổi nó khi đáp ứng các điều kiện trong if-expressions.

说明：
- ```variable_name``` - Pine Script中允许的用户变量的任何名称（可以包含大写和小写的拉丁字符，数字和下划线（_），但不能以数字开头）。
- ```expression``` - 任何算术表达式，就像定义常规变量一样。 将计算表达式并将其分配给变量一次。  

**例子**
```pine
// Var keyword example
var a = close
var b = 0.0
var c = 0.0
var green_bars_count = 0
if close > open
    var x = close
    b := x
    green_bars_count := green_bars_count + 1
    if green_bars_count >= 10
        var y = close
        c := y
plot(a, title = "a")
plot(b, title = "b")
plot(c, title = "c")

Các biến a giữ giá đóng cửa của hàng đầu của mỗi hàng trong chuỗi. Các biến số b giữ giá đóng cửa của thanh giá n màu xanh lá cây n đầu tiên trong loạt n. Các biến c giữ giá đóng cửa của con số 10 trong loạt các con số.

Trên FMZ, các mô hình giá thực tế, mô hình giá đóng cửa, mô hình giá bán, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực, mô hình giá bán trong thời gian thực.var、varipCác biến được tuyên bố chúng tôi thử nghiệm bằng mã sau đây.

strategy("test pine", "test 1", true) 

// 测试 var varip
var i = 0
varip ii = 0

// 将策略逻辑每轮改变的i、ii打印在图上
plotchar(true, title="ii", char=str.tostring(ii), location=location.abovebar, color=color.red)
plotchar(true, title="i", char=str.tostring(i), location=location.belowbar, color=color.green)

// 每轮逻辑执行都给i、ii递增1
if true
    i := i + 1
    ii := ii + 1

• Mô hình giá thời gian thực Mã thử nghiệm trên được phân chia thành hai giai đoạn khi thực hiện: 1, giai đoạn đường K lịch sử. 2, giai đoạn đường K thời gian thực.var、varipCác biến i, ii được tuyên bố sẽ thực hiện các thao tác tăng dần mỗi lần thực hiện mã chính sách vìif trueVì vậy, chắc chắn sẽ thực hiện các phần mã điều kiện tương ứng). Vì vậy, bạn có thể thấy rằng các số hiển thị trên kết quả K-line BAR đều tăng lên 1. Khi giai đoạn K-line lịch sử kết thúc, bắt đầu giai đoạn K-line thời gian thực.var、varipCác biến được tuyên bố bắt đầu thay đổi khác nhau. Bởi vì đó là mô hình giá thực tế, mỗi lần thay đổi giá trong một dòng KBAR sẽ được thực hiện một lần mã chiến lược.i := i + 1vàii := ii + 1Chỉ có một sự khác biệt là i được thay đổi mỗi lần. i vẫn được thay đổi, nhưng giá trị trước đó sẽ được khôi phục lại khi logic chính sách được thực hiện lần tiếp theo, và sẽ không được cập nhật cho đến khi dòng K BAR hiện tại kết thúc (có nghĩa là giá trị trước đó sẽ không được khôi phục lại khi logic chính sách được thực hiện lần tiếp theo). Vì vậy, chúng ta có thể thấy biến i vẫn là BAR1 mỗi lần; nhưng biến ii được thêm nhiều lần mỗi BAR.

• Mô hình giá đóng cửa Vì mô hình giá đóng là thực hiện một chiến lược logic mỗi khi mỗi K-line BAR đi qua. Vì vậy, trong mô hình giá đóng, giai đoạn K-line lịch sử và giai đoạn K-line thời gian thực sẽ được sử dụng để xác định giá của các dòng.var、varipCác biến được tuyên bố diễn ra hoàn toàn đồng bộ trong các ví dụ trên, tăng dần, mỗi K-line BAR tăng lên 1.

khác nhau

varip (var intrabar persist) là một từ khóa dùng để phân bổ và khởi tạo một lần các biến. Nó tương tự như từ khóa var, nhưng các biến được sử dụng trong tuyên bố varip giữ giá trị giữa các bản cập nhật dòng K trong thời gian thực.

说明：
- ```variable_name``` - Pine脚本中允许的用户变量的任何名称（可以包含大写和小写拉丁字符、数字和下划线(_)，但不能以数字开头）。
- ```expression``` - 任何算术表达式，就像定义常规变量时一样。在第一根K线上，表达式仅计算一次并将其分配给变量一次。  

**例子**
```pine
// varip
varip int v = -1
v := v + 1
plot(v)

Khi sử dụng var, biểu đồ sẽ trả về giá trị của bar_index. Sử dụng varip, hành vi tương tự sẽ xảy ra trên đường K lịch sử, nhưng trên đường K thời gian thực, biểu đồ sẽ trả về một giá trị, tăng một cho mỗi dấu chấm.

Nhận xétChỉ được sử dụng với các kiểu đơn giản như float, int, boolean, string, và các mảng của kiểu này.

đúng

Định giá trị của một biến dạng Boolean, hoặc khi biểu thức được sử dụngSo sánhHoặcLý thuyếtGiá trị mà các toán tử có thể tính toán.

Nhận xétXem thêmSo sánhCác toán tử vàLý thuyếtMô tả các toán tử.

Hẹn gặp lại

  
### false

表示一个布尔类型变量的值，以及比较操作、逻辑操作的结果。

**备注**
请参阅**比较**运算符和**逻辑**运算符的描述。

**另见**
```bool```

### if

If语句定义了在满足表达式条件时必须执行的语句块。第4版的Pine脚本语言允许您使用“else if”语法。

通用编码来自：

var_declarationX = if condition var_decl_then0 var_decl_then1 ... var_decl_thenN return_expression_then Nếu không [lựa chọn] var_decl_else0 var_decl_else1 ... var_decl_elseN return_expression_else khác var_decl_else0 var_decl_else1 ... var_decl_elseN return_expression_else

**备注**
```var_declarationX``` - 此变量获取if语句的值
```condition``` - 如果条件为true，则使用语句块```then```中的逻辑(```var_decl_then0```，```var_decl_then1```等)。如果条件为false，则使用语句块```else if```或者```else```中的逻辑(```var_decl_else0```，```var_decl_else1```等)。
```return_expression_then , return_expression_else``` - 模块中的最后一个表达式或者来自块else的表达式将返回语句的最终值。 如果变量的声明在最后，它的值将是结果值。

if语句的返回值的类型取决于```return_expression_then```和```return_expression_else```类型。TradingView上运行时，它们的类型必须匹配：当你在else块中有一个字符串值时，不可能从then语句块返回一个整数值。在FMZ上运行时，以下例子不会报错，当y值取值"open"时，plot画图时的数值为n/a。

**例子**
```pine
// This code compiles
x = if close > open
    close
else
    open  

// This code doesn’t compile by trading view
// y = if close > open
//     close
// else
//     "open"
plot(x)

Có thể bỏ quaelseTrong trường hợp này, nếu điều kiện là false, thì sẽ gán một threshold empty (na,false hoặc) cho biến var_declarationX:

Ví dụ

// if
x = if close > open
    close
// If current close > current open, then x = close.
// Otherwise the x = na.
plot(x)

Có thể sử dụng nhiều khối if hoặc không sử dụng. Các khối then, if, if được di chuyển qua bốn không gian:

Ví dụ

// if
x = if open > close
    5
else if high > low
    close
else
    open
plot(x)

Có thể bỏ quaifGiá trị kết quả của câu nói ((var_declarationX= có thể bỏ qua) ). Nó có thể hữu ích nếu bạn cần một tác dụng phụ của biểu thức, ví dụ như trong giao dịch chiến lược:

Ví dụ

if (ta.crossover(high, low))
    strategy.entry("BBandLE", strategy.long, stop=low)
else
    strategy.cancel(id="BBandLE")

Các câu if có thể chứa lẫn nhau:

Ví dụ

// if
float x = na
if close > open
    if close > close[1]
        x := close
    else
        x := close[1]
else
    x := open
plot(x)

cho

Các cấu trúc for được sử dụng để cho phép lặp lại nhiều câu:

[var_declaration =] for counter = from_num to to_num [by step_num]
    statements | continue | break
    return_expression

```counter``` - 保存回圈计数器值的变数，在回圈的每次迭代中递增/递减 1 或 step_num 值。
```from_num``` - 计数器的起始值。允许使用“series int/float”值/表达式。
```to_num``` - 计数器的最终值。当计数器大于to_num（或小于to_num在from_num > to_num的情况下）时，循环中断。允许使用“series int/float”值/表达式，但它们仅在循环的第一次迭代时进行评估。
```step_num``` - 计数器的递增/递减值。它是可选的。默认值为+1或-1，具体取决于from_num或to_num中最大的一个。使用值时，计数器也会根据from_num或to_num中最大的那个而递增/递减，因此step_num的+/-符号是可选的。
```statements | continue | break``` - 任意数量的语句，或'continue'或'break'关键字，缩进4个空格或一次 tab。
```return_expression``` - 循环的返回值，如果存在，则分配给var_declaration中的变量。 如果循环由于“continue”或“break”关键字而退出，则循环的返回值是在循环退出之前分配值的最后一个变量的返回值。
```continue``` - 只能在回圈中使用的关键字。它导致回圈的下一次迭代被执行。
```break``` - 退出回圈的关键字。

**例子**
```pine
// Here, we count the quantity of bars in a given 'lookback' length which closed above the current bar's close
qtyOfHigherCloses(lookback) =>
    int result = 0
    for i = 1 to lookback
        if close[i] > close
            result += 1
    result
plot(qtyOfHigherCloses(14))

Hẹn gặp lại

  
### for...in

`for...in` 结构允许为数组中的每个元素重复执行多个语句。它可以与任一参数一起使用：`array_element`，或与两个参数一起使用：`[index, array_element]`。 第二种形式不影响循环的功能。它在元组的第一个变量中跟踪当前迭代的索引。

[var_declaration =] cho array_element trong array_id Lời tuyên bố tiếp tục. return_expression

[var_declaration =] cho [index, array_element] trong array_id Lời tuyên bố tiếp tục. return_expression

```var_declaration``` - 一个可选的变量声明，将被赋予循环的 `return_expression` 的值。
```index``` - 跟踪当前迭代索引的可选变量。索引从 0 开始。变量在循环体中是不可变的。使用时，它必须包含在一个也包含 `array_element` 的元组中。
```array_element``` - 包含要在循环中处理的每个连续阵列元素的变量。该变量在循环体中是不可变的。
```array_id``` - 回圈迭代的阵列ID。
```statements | continue | break``` - 任意数量的语句，或'continue'或'break'关键字，缩进4个空格或一次 tab。
```return_expression``` - 循环的返回值分配给 `var_declaration` 中的变量，如果存在的话。 如果循环由于'continue'或'break'关键字而退出，则循环的返回值是循环退出前最后一个赋值的变量。
```continue``` - 只能在回圈中使用的关键字。它导致回圈的下一次迭代被执行。
```break``` - 退出回圈的关键字。

允许在循环内修改阵列的元素或其大小。
在这里，我们使用 `for...in` 的单参数形式来确定在每个K线上，有多少K线的OHLC值大于'close'值的SMA：

**例子**
```pine
// Here we determine on each bar how many of the bar's OHLC values are greater than the SMA of 'close' values
float[] ohlcValues = array.from(open, high, low, close)
qtyGreaterThan(value, array) =>
    int result = 0
    for currentElement in array
        if currentElement > value
            result += 1
        result
plot(qtyGreaterThan(ta.sma(close, 20), ohlcValues))

Ở đây, chúng ta sử dụng hai dạng đối số for...in để tạo ra chúng taisPosCác giá trị của mảng được đặt làtrueKhi chúng ở trong nhà chúng tôi,valuesArrayCác giá trị tương ứng trong các tập hợp là:

Ví dụ

// for...in
var valuesArray = array.from(4, -8, 11, 78, -16, 34, 7, 99, 0, 55)
var isPos = array.new_bool(10, false)  

for [index, value] in valuesArray
    if value > 0
        array.set(isPos, index, true)  

if barstate.islastconfirmedhistory
    runtime.log(str.tostring(isPos))

Hẹn gặp lại

### while

`while`语句允许本地代码块的条件迭代。

variable_declaration = while boolean_expression ... tiếp tục ... ngưng ... return_expression

说明：
```variable_declaration``` - 可选的变量声明。`return expression`可以为这个变量提供初始化值。
```boolean_expression``` - 如果为true，则执行`while`语句的本地块。如果为false，则在`while`语句之后继续执行脚本。
```continue``` - `continue` 关键字导致循环分支到下一次迭代。
```break``` - `break` 关键字导致循环终止。脚本的执行在 `while` 语句之后恢复。
```return_expression``` - 提供 `while` 语句返回值的可选行。

**例子**
```pine
// This is a simple example of calculating a factorial using a while loop.
int i_n = input.int(10, "Factorial Size", minval=0)
int counter   = i_n
int factorial = 1
while counter > 0
    factorial := factorial * counter
    counter   := counter - 1

plot(factorial)

Nhận xétĐầu tiênwhileCác khối mã địa phương sau hàng phải được thu nhỏ thành bốn không gian hoặc một ký tự.whileVòng tròn.whileCác biểu thức Boole sau phải trở thành false hoặc phải thực hiệnbreak。

chuyển đổi

Switch chuyển quyền kiểm soát sang một trong vài câu nói dựa trên giá trị của điều kiện và biểu thức.

[variable_declaration = ] switch expression
    value1 => local_block
    value2 => local_block
    ...
    => default_local_block

[variable_declaration = ] switch
    boolean_expression1 => local_block
    boolean_expression2 => local_block
    ...
    => default_local_block

Một số người nói rằng, "Điều này không phải là điều tốt".

Ví dụ

// Switch using an expression

string i_maType = input.string("EMA", "MA type", options = ["EMA", "SMA", "RMA", "WMA"])

float ma = switch i_maType
    "EMA" => ta.ema(close, 10)
    "SMA" => ta.sma(close, 10)
    "RMA" => ta.rma(close, 10)
    // Default used when the three first cases do not match.
    => ta.wma(close, 10)

plot(ma)

Một số người đã viết bài viết trên trang web của mình.

Ví dụ

strategy("Switch without an expression", overlay = true)

bool longCondition  = ta.crossover( ta.sma(close, 14), ta.sma(close, 28))
bool shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))

switch
    longCondition  => strategy.entry("Long ID", strategy.long)
    shortCondition => strategy.entry("Short ID", strategy.short)

Trả về giá trịGiá trị của biểu thức cuối cùng trong khối câu lệnh địa phương được thực hiện.

Nhận xétChỉ có thể thực hiệnlocal_blockví dụ hoặcdefault_local_blockMột trong số đó.default_local_blockChỉ với=>Chữ đánh dấu được giới thiệu cùng với nhau và chỉ được thực hiện khi không thực hiện khối trước đó; nếuswitchKết quả của câu nói được gán cho một biến và không được chỉ địnhdefault_local_blockNếu không thực hiệnlocal_blockVà sau đó, câu trả lời sẽ trở lại.na◎ sẽswitchKhi kết quả của câu nói được gán cho một biến, tất cảlocal_blockCác trường hợp phải trả về cùng một kiểu giá trị.

Hẹn gặp lại

### series

series是一个关键字，表示数据系列类型。显式使用 `series` 关键字通常是不必要的。

## 运算符

### =

用于给变量赋值，但仅在声明变量时（第一次使用）。

### :=

赋值运算符，给左侧变量赋值。用于为先前声明的变量赋值。

### !=

不等于。适用于任何类型的表达式。

expr1!= expr2

**返回值**
布尔值，或一系列布尔值。

### %

模数(整数余数)。 适用于数值表达式。

expr1 % expr2

**返回值**
整数或浮点值，或一系列值。

**备注**
在Pine脚本中，当计算整数的余数时，商将被截断。 即，将其四舍五入到最小绝对值。 所得值将具有与股息相同的符号。

示例：-1 % 9 = -1 - 9 * truncate(-1/9) = -1 - 9 * truncate(-0.111) = -1 - 9 * 0 = -1。

### %=

模数指派。适用于数值表达式。

expr1 %= expr2

**例子**
```pine
// Equals to expr1 = expr1 % expr2.
a = 3
b = 3
a %= b
// Result: a = 0.
plot(a)

Trả về giá trịMột số nguyên hoặc một giá trị trôi, hoặc một chuỗi các giá trị.

*

Xét nhân... áp dụng cho biểu thức số.

expr1 * expr2

Trả về giá trịMột số nguyên hoặc một giá trị trôi, hoặc một chuỗi các giá trị.

*=

Định nghĩa nhân.

expr1 *= expr2

Ví dụ

// Equals to expr1 = expr1 * expr2.
a = 2
b = 3
a *= b
// Result: a = 6.
plot(a)

Trả về giá trịMột số nguyên hoặc một giá trị trôi, hoặc một chuỗi các giá trị.

+

Thêm hoặc đơn vị chính thức.

expr1 + expr2

+ expr

Trả về giá trịHệ thống nhị phân của chuỗi+Trả về sự kết hợp của express1 và express2 Số trả về một số nguyên hoặc một giá trị dấu phẩy, hoặc một chuỗi các giá trị: Chế độ nhị phân xy + xy trở lại express1 cộng với express2// Một đơn vị + một đơn vị trả về expres (không thêm bất kỳ nội dung nào vào đối xứng của một đơn vị).

Nhận xétBạn có thể sử dụng các toán tử toán học với số và số lượng các biến. Trong trường hợp sử dụng các số lượng, các toán tử được áp dụng cho các phần tử.

+=

Định nghĩa gia hạn... được sử dụng cho biểu thức số hoặc chuỗi...

expr1 += expr2

Ví dụ

// Equals to expr1 = expr1 + expr2.
a = 2
b = 3
a += b
// Result: a = 5.
plot(a)

Trả về giá trịĐối với các chuỗi, trả về chuỗi express1 và express2; đối với các số, trả về số nguyên hoặc giá trị dấu phẩy, hoặc một chuỗi các giá trị.

Nhận xétBạn có thể sử dụng các toán tử toán học với số và số lượng các biến. Trong trường hợp sử dụng các số lượng, các toán tử được áp dụng cho các phần tử.

-

Phân trừ hoặc số âm đơn.

expr1 - expr2

- expr

Trả về giá trịTrả về một số nguyên hoặc một giá trị trôi, hoặc một chuỗi các giá trị: Hàm nhị phân + nhị phân trả về expres1 trừ expres2. Một đồng-Trả lại từ chối của expres.

Nhận xétBạn có thể sử dụng các toán tử toán học với số và số lượng các biến. Trong trường hợp sử dụng các số lượng, các toán tử được áp dụng cho các phần tử.

-=

Định nghĩa trừu tượng.

expr1 -= expr2

Ví dụ

// Equals to expr1 = expr1 - expr2.
a = 2
b = 3
a -= b
// Result: a = -1.
plot(a)

Trả về giá trịMột số nguyên hoặc một giá trị trôi, hoặc một chuỗi các giá trị.

/

Ngoại trừ. áp dụng cho biểu thức số.

expr1 / expr2

Trả về giá trịMột số nguyên hoặc một giá trị trôi, hoặc một chuỗi các giá trị.

/=

Trừ khi chỉ định.

expr1 /= expr2

Ví dụ

// Equals to expr1 = expr1 / expr2.
a = 3
b = 3
a /= b
// Result: a = 1.
plot(a)

Trả về giá trịMột số nguyên hoặc một giá trị trôi, hoặc một chuỗi các giá trị.

<

Ít hơn. Đối với các biểu thức số.

expr1 < expr2

Trả về giá trịGiá trị Boolean, hoặc một chuỗi giá trị Boolean.

<=

Ít hơn hoặc bằng.

expr1 <= expr2

Trả về giá trịGiá trị Boolean, hoặc một chuỗi giá trị Boolean.

==

Có thể sử dụng cho bất kỳ loại biểu thức nào.

expr1 == expr2

Trả về giá trịGiá trị Boolean, hoặc một chuỗi giá trị Boolean.

=>

Các toán tử => được sử dụng cho các tuyên bố hàm được xác định bởi người dùng vàswitchTrong câu nói.

Phương pháp lập trình của function declaration là:

<identifier>([<parameter_name>[=<default_value>]], ...) =>
    <local_block>
    <function_result>

Một<local_block>Một số câu nói của Pine là 0 hoặc nhiều hơn.

**例子**
```pine
// single-line function
f1(x, y) => x + y
// multi-line function
f2(x, y) => 
    sum = x + y
    sumChange = ta.change(sum, 10)
    // Function automatically returns the last expression used in it
plot(f1(30, 8) + f2(1, 3))

Nhận xétBạn có thể tìm hiểu thêm về các hàm được định nghĩa bởi người dùng trên trang tuyên bố hàm và thư mục kịch bản trong hướng dẫn người dùng.

>

lớn hơn. áp dụng cho các biểu thức số.

expr1 > expr2

Trả về giá trịGiá trị Boolean, hoặc một chuỗi giá trị Boolean.

>=

lớn hơn hoặc bằng.

expr1 >= expr2

Trả về giá trịGiá trị Boolean, hoặc một chuỗi giá trị Boolean.

?:

Các toán tử điều kiện ba nguyên tắc.

expr1 ? expr2 : expr3

Ví dụ

// Draw circles at the bars where open crosses close
s2 = ta.cross(open, close) ? math.avg(open,close) : na
plot(s2, style=plot.style_circles, linewidth=2, color=color.red)  

// Combination of ?: operators for 'switch'-like logic
c = timeframe.isintraday ? color.red : timeframe.isdaily ? color.green : timeframe.isweekly ? color.blue : color.gray
plot(hl2, color=c)

Trả về giá trịNếu expres1 được đánh giá là true, expres2 sẽ được đánh giá là true, nếu không thì expres3 sẽ được đánh giá là true.

Nhận xétNếu bạn không cần, hãy sử dụng na như là một nhánh của nhánh Else. Bạn có thể sử dụng hai hoặc nhiều hơn: các ký hiệu để thực hiện các câu tương tự như các dấu hiệu chuyển đổi (xem ví dụ trên). Bạn có thể sử dụng các toán tử toán học với số và số lượng các biến. Trong trường hợp sử dụng các số lượng, các toán tử được áp dụng cho các phần tử.

Hẹn gặp lại

### []

系列下标。 提供对expr1系列的以前值的访问。 expr2是过去k线的数目，必须是数值。 浮动将被向下舍入。

expr1[expr2]

**例子**
```pine
// [] can be used to "save" variable value between bars
a = 0.0 // declare `a`
a := a[1] // immediately set current value to the same as previous. `na` in the beginning of history
if high == low // if some condition - change `a` value to another
    a := low
plot(a)

Trả về giá trịMột loạt các giá trị.

Hẹn gặp lại

### and

逻辑 AND。适用于布尔表达式。

expr1 và expr2

**返回值**
布尔值，或一系列布尔值。

### or

逻辑 OR。适用于布尔表达式。

expr1 hoặc expr2

**返回值**
布尔值，或一系列布尔值。

### not

逻辑求反(NOT)。 适用于布尔表达式。

không expr1

**返回值**
布尔值，或一系列布尔值。

## 数据类型关键字

### bool

用于显式声明变量或参数的“bool”（布尔）类型的关键字。"Bool"变量的值可以是true、false或na。

**例子**
```pine
// bool
bool b = true    // Same as `b = true`
b := na
plot(b ? open : close)

Nhận xétViệc đề cập rõ ràng đến kiểu trong tuyên bố biến là tùy chọn, trừ khi nó được khởi tạo bằng na. Tìm hiểu thêm về kiểu Pine trên trang hướng dẫn người dùng của hệ thống kiểu.

Hẹn gặp lại

### int

用于显式声明变量或参数的“int”（整数）类型的关键字。  

**例子**
```pine
// int
int i = 14    // Same as `i = 14`
i := na
plot(i)

Nhận xétViệc đề cập rõ ràng đến kiểu trong tuyên bố biến là tùy chọn, trừ khi nó được khởi tạo bằng na. Tìm hiểu thêm về kiểu Pine trên trang hướng dẫn người dùng của hệ thống kiểu.

Hẹn gặp lại

### float

用于显式声明变量或参数的“float”（浮点）类型的关键字。  

**例子**
```pine
// float
float f = 3.14    // Same as `f = 3.14`
f := na
plot(f)

Nhận xétViệc đề cập rõ ràng đến kiểu trong tuyên bố biến là tùy chọn, trừ khi nó được khởi tạo bằng na.

Hẹn gặp lại

### string

用于显式声明变量或参数的"string"类型的关键字。

**例子**
```pine
// string
string s = "Hello World!"    // Same as `s = "Hello world!"`
// string s = na // same as "" 
plot(na, title=s)

Nhận xétViệc đề cập rõ ràng đến kiểu trong tuyên bố biến là tùy chọn, trừ khi nó được khởi tạo bằng na. Tìm hiểu thêm về kiểu Pine trên trang hướng dẫn người dùng của hệ thống kiểu.

Hẹn gặp lại

### color

用于显式声明变量或参数的"color"类型的关键字。

**例子**
```pine
// color
color textColor = color.green
if barstate.islastconfirmedhistory
    runtime.log("test", textcolor = textColor)

Nhận xétChữ màu có định dạng như sau: #RRGGBB hoặc #RRGGBBAA. Các chữ cái đại diện cho giá trị mười sáu chữ số từ 00 đến FF (từ 0 đến 255 chữ số), trong đó RR,GG và BB là các giá trị của các phân số màu đỏ, xanh lá cây và xanh dương. AA là các giá trị tùy chọn cho độ minh bạch màu (hoặc phân số alpha), trong đó 00 không nhìn thấy được, FF không minh bạch. Việc đề cập rõ ràng đến kiểu trong tuyên bố biến là tùy chọn, trừ khi nó được khởi tạo bằng na. Tìm hiểu thêm về kiểu Pine trên trang hướng dẫn người dùng của hệ thống kiểu.

Hẹn gặp lại

### array

用于显式声明变量或参数的“阵列”类型的关键字。可以使用```array.new<type>```,```array.from```函数创建阵列对象（或ID）。

**例子**
```pine
// array
array<float> a = na
a := array.new<float>(1, close)
plot(array.get(a, 0))

Nhận xétCác đối tượng trong mảng luôn có hình thức mảng của chuỗi.

Hẹn gặp lại

### Objects

PINE语言的Objects对象是用户定义类型（UDT）的实例，可以理解为无方法类，允许用户在策略中创建自定义类型在一个实体中组织不同的值。

**定义类型**

  让我们定义一个order类型来保存订单信息：
```pine
type order
    float price
    float amount
    string symbol

• Sử dụngtypeCác loại tuyên bố từ khóa.
• type sau từ khóa type là tên kiểu.
• Dòng đầu tiên type xác định tên kiểu, sau đó thu hẹp bốn không gian để xác định trường chứa kiểu.
• Mỗi trường cần phải xác định kiểu dữ liệu của nó, chẳng hạn như int, float, string.

Tạo đối tượng

Sử dụng kiểu được tuyên bố tốt, gọinew()Các chức năng tạo đối tượng:

order1 = order.new()

order1 = order.new(100, 0.1, "BTC_USDT")

order1 = order.new(amount = 0.1, symbol = "BTC_USDT", price = 100)

Bạn cũng có thể tạo các đối tượng trống:

order order1 = na

Dưới đây là một ví dụ thực tế:

type order
    float price
    float amount
    string symbol

if strategy.position_size == 0 and open > close
    strategy.entry("long", strategy.long, 1)

order1 = order.new(strategy.opentrades.entry_price(strategy.opentrades - 1), strategy.opentrades.size(strategy.opentrades - 1), syminfo.ticker)
// runtime.log(order1)   // 输出 {"data":{"price":46002.8,"amount":1,"symbol":"swap"},"_meta":0,"_type":"order"}

Ví dụ:

order1 = order.new(strategy.opentrades.entry_price(strategy.opentrades - 1), strategy.opentrades.size(strategy.opentrades - 1), syminfo.ticker)

Bạn có thể viết theo các hình thức sau:

order order1 = na
order1 := order.new(strategy.opentrades.entry_price(strategy.opentrades - 1), strategy.opentrades.size(strategy.opentrades - 1), syminfo.ticker)

Loại đối tượng được sử dụng cho từ khóa var

//@version=5
indicator("Objects using `var` demo")

//@type A custom type to hold index, price, and volume information.
type BarInfo
    int   index = bar_index
    float price = close
    float vol   = volume

//@variable A `BarInfo` instance whose fields persist through all iterations, starting from the first bar.
var BarInfo firstBar = BarInfo.new()
//@variable A `BarInfo` instance declared on every bar.
BarInfo currentBar = BarInfo.new()

// Plot the `index` fields of both instances to compare the difference.
plot(firstBar.index, "firstBar")
plot(currentBar.index, "currentBar")

Khi sử dụng tuyên bố từ khóa var để gán một biến đối tượng với kiểu xác định của người dùng, từ khóa này sẽ tự động được áp dụng cho tất cả các trường của đối tượng đó. Điều này có nghĩa là đối tượng được tuyên bố bằng từ khóa var sẽ giữ trạng thái của nó giữa mỗi lần lặp mà không cần phải khởi tạo lại giá trị trường của nó trong mỗi lần lặp.

• Đối tượng firstBar được tuyên bố bằng từ khóa var, vì vậy các trường của nó (index, price, vol) sẽ giữ giá trị của nó trong mỗi lần lặp, từ đầu tiên đến cuối cùng.
• Đối tượng currentBar không sử dụng tuyên bố từ khóa var, vì vậy các trường của nó sẽ được khởi tạo lại trên mỗi mục và sẽ có một đối tượng mới trong mỗi lần lặp.

Bạn có thể so sánh sự khác biệt giữa hai đối tượng bằng cách vẽ các trường index. firstBar.index sẽ giữ giá trị được đặt trước đó trong mỗi lần lặp, trong khi currentBar.index sẽ được khởi tạo lại với giá trị bar_index của mục hiện tại trong mỗi lần lặp.

Loại đối tượng được sử dụng cho từ khóa varip

//@version=5
indicator("Objects using `varip` fields demo")

//@type A custom type that counts the bars and ticks in the script's execution.
type Counter
    int       bars  = 0
    varip int ticks = 0

//@variable A `Counter` object whose reference persists throughout all bars.
var Counter counter = Counter.new()

// Add 1 to the `bars` and `ticks` fields. The `ticks` field is not subject to rollback on unconfirmed bars.
counter.bars  += 1
counter.ticks += 1

// Plot both fields for comparison.
plot(counter.bars, "Bar counter", color.blue, 3)
plot(counter.ticks, "Tick counter", color.purple, 3)

Trong Pine, sử dụng từ khóa varip để chỉ ra một trường đối tượng tồn tại liên tục trong suốt quá trình thực thi kịch bản, thay vì quay lại trong các cột chưa xác định. Trong tuyên bố kiểu Counter, trường bars không sử dụng từ khóa varip và do đó sẽ quay lại trong mỗi cột không xác nhận; trong khi trường ticks sử dụng từ khóa varip và do đó nó sẽ không quay lại trong cột không xác nhận. Đối tượng counter được tuyên bố bằng từ khóa var, do đó nó sẽ tồn tại suốt quá trình thực hiện kịch bản. Trong mỗi lần lặp lại, các trường bars và ticks sẽ được thêm một. Các trường bars sẽ quay lại trong mỗi cột chưa xác định, trong khi các trường ticks sẽ không quay lại. Cuối cùng, bằng cách vẽ các trường counter.bars và counter.ticks, bạn có thể so sánh sự khác biệt giữa chúng. Giá trị của counter.bars sẽ được lật ngược trong mỗi cột chưa xác định, trong khi giá trị của counter.ticks sẽ tiếp tục tăng lên cho đến khi kịch bản hoàn thành.

Thay đổi giá trị trường

type order
    float price
    float amount
    string symbol

if strategy.position_size == 0 and open > close
    strategy.entry("long", strategy.long, 1)
    
order1 = order.new(strategy.opentrades.entry_price(strategy.opentrades - 1), strategy.opentrades.size(strategy.opentrades - 1), syminfo.ticker)

if strategy.position_size != 0
    runtime.log(order1)
    order1.price := 999
    order1.amount := 100
    runtime.log(order1)
    runtime.error("stop")

Có thể sử dụng:=Chế toán tái gán thay đổi giá trị của trường đối tượng.

Tập hợp đối tượng

Ví dụ: khai một Array trống, mà sẽ lưu các đối tượng với loại order được xác định bởi người dùng:

type order
    float price
    float amount
    string symbol

arrOrder = array.new<order>()

order1 = order.new(99, 1, "BTC_USDT")
order2 = order.new(100, 2, "ETH_USDT")

array.push(arrOrder, order1)
array.push(arrOrder, order2)

runtime.log(arrOrder)
runtime.error("stop")

Hoặc

type order
    float price
    float amount
    string symbol

var array<order> arrOrder = na
arrOrder := array.new<order>()

order1 = order.new(99, 1, "BTC_USDT")
order2 = order.new(100, 2, "ETH_USDT")

array.push(arrOrder, order1)
array.push(arrOrder, order2)

runtime.log(arrOrder)
runtime.error("stop")

Các đối tượng sao chép

Trong Pine, các đối tượng được gán bằng cách tham chiếu. Khi các đối tượng hiện có được gán cho các biến mới, cả hai đều trỏ đến cùng một đối tượng.

//@version=5
indicator("")
type pivotPoint
    int x
    float y
pivot1 = pivotPoint.new()
pivot1.x := 1000
pivot2 = pivot1
pivot2.x := 2000
// Both plot the value 2000.
plot(pivot1.x)
plot(pivot2.x)

Trong ví dụ dưới đây, chúng ta tạo một đối tượng pivot1 và đặt trường x của nó là 1000. Sau đó, chúng ta tuyên bố một pivot2 chứa một biến có tham chiếu đến đối tượng pivot1 đó, do đó, cả hai đều trỏ đến cùng một trường hợp. Do đó, thay đổi pivot2.x cũng sẽ thay đổi pivot1.x, vì cả hai đều tham chiếu đến trường x của cùng một đối tượng.

Để tạo ra một bản sao độc lập với đối tượng gốc, trong trường hợp này chúng ta có thể sử dụng phương pháp copy ((()) được xây dựng. Trong ví dụ này, chúng ta tuyên bố pivot2 tham chiếu đến một biến của một trường hợp sao chép đối tượng pivot1. Bây giờ, thay đổi pivot2.x sẽ không thay đổi pivot1.x vì nó chỉ ra một trường x của một đối tượng riêng biệt:

//@version=5
indicator("")
type pivotPoint
    int x
    float y
pivot1 = pivotPoint.new()
pivot1.x := 1000
pivot2 = pivotPoint.copy(pivot1)
pivot2.x := 2000
// Plots 1000 and 2000.
plot(pivot1.x)
plot(pivot2.x)

Lưu ý rằng phương pháp sao chép của TradingView là sao chép cơ bản. Nếu một đối tượng có một loại trường đặc biệt (như array, v.v.), thì các trường trong bản sao cơ bản của đối tượng đó sẽ trỏ đến cùng một trường hợp với đối tượng đó. FMZ thực hiện bản sao sâu trực tiếp mà không cần xử lý thêm.

Sao chép sâu

//@version=5

indicator("test deepCopy")

type orderInfo
    float price
    float amount

type labelInfo
    orderInfo order
    string labelMsg

labelInfo1 = labelInfo.new(orderInfo.new(100, 0.1), "test labelInfo1")
labelInfo2 = labelInfo.copy(labelInfo1)

labelInfo1.labelMsg := "labelInfo1->2"    // 修改 labelInfo1 的基础类型字段，看是否影响 labelInfo2
labelInfo1.order.price := 999             // 修改 labelInfo1 的复合类型字段，看是否影响 labelInfo2

runtime.log(labelInfo1)
runtime.log(labelInfo2)
runtime.error("stop")

Kết quả thử nghiệm, labelInfo.copy ((labelInfo1) được thực hiện để sao chép sâu, thay đổi labelInfo1 không ảnh hưởng đến labelInfo2.

Phương pháp

Các phương thức của ngôn ngữ Pine là các hàm chuyên dụng liên quan đến kiểu tích hợp hoặc kiểu xác định của người dùng trong một trường hợp cụ thể. Trong hầu hết các khía cạnh, chúng tương tự như các hàm thông thường, nhưng cung cấp một ngữ pháp ngắn hơn và thuận tiện hơn. Người dùng có thể trực tiếp sử dụng dấu chấm để truy cập các phương thức trên biến, giống như truy cập các trường đối tượng Pine.

Phương pháp xây dựng

Ví dụ, một đoạn mã như thế này:

//@version=5
indicator("Custom Sample BB", overlay = true)

float sourceInput  = input.source(close, "Source")
int   samplesInput = input.int(20, "Samples")
int   n            = input.int(10, "Bars")
float multiplier   = input.float(2.0, "StdDev")

var array<float> sourceArray = array.new<float>(samplesInput)
var float        sampleMean  = na
var float        sampleDev   = na

// Identify if `n` bars have passed.
if bar_index % n == 0
    // Update the queue.
    array.push(sourceArray, sourceInput)
    array.shift(sourceArray)
    // Update the mean and standard deviaiton values.
    sampleMean := array.avg(sourceArray)
    sampleDev  := array.stdev(sourceArray) * multiplier

// Calculate bands.
float highBand = sampleMean + sampleDev
float lowBand  = sampleMean - sampleDev

plot(sampleMean, "Basis", color.orange)
plot(highBand, "Upper", color.lime)
plot(lowBand, "Lower", color.red)

Có thể viết là:

//@version=5
indicator("Custom Sample BB", overlay = true)

float sourceInput  = input.source(close, "Source")
int   samplesInput = input.int(20, "Samples")
int   n            = input.int(10, "Bars")
float multiplier   = input.float(2.0, "StdDev")

var array<float> sourceArray = array.new<float>(samplesInput)
var float        sampleMean  = na
var float        sampleDev   = na

// Identify if `n` bars have passed.
if bar_index % n == 0
    // Update the queue.
    sourceArray.push(sourceInput)
    sourceArray.shift()
    // Update the mean and standard deviaiton values.
    sampleMean := sourceArray.avg()
    sampleDev  := sourceArray.stdev() * multiplier

// Calculate band values.
float highBand = sampleMean + sampleDev
float lowBand  = sampleMean - sampleDev

plot(sampleMean, "Basis", color.orange)
plot(highBand, "Upper", color.lime)
plot(lowBand, "Lower", color.red)

Bạn có thể thấy sự hỗ trợ của PINE.MethodsSau đó, mãarray.avg(sourceArray)Bạn có thể viết theo hình thức phương pháp của người dùng:sourceArray.avg()❖ Lưu ý FMZ không hỗ trợarray.avgNhững lời kêu gọi như vậy.

Phương pháp được xác định bởi người dùng

Pine cho phép người dùng xác định một phương thức tùy chỉnh để sử dụng cùng với bất kỳ đối tượng kiểu được xây dựng hoặc xác định bởi người dùng nào.

1, phương thức từ khóa phải được bao gồm trước tên của hàm. 2, một tham số của method, trong đó kiểu của parameter đầu tiên phải được tuyên bố rõ ràng vì nó cho biết kiểu đối tượng mà method sẽ liên kết với nó.

Ví dụ, cách gói mã tính toán chỉ số Brinh thành một phương pháp tùy chỉnh của người dùng trong các mã sau:

//@version=5
indicator("Custom Sample BB", overlay = true)

float sourceInput  = input.source(close, "Source")
int   samplesInput = input.int(20, "Samples")
int   n            = input.int(10, "Bars")
float multiplier   = input.float(2.0, "StdDev")

var array<float> sourceArray = array.new<float>(samplesInput)
var float        sampleMean  = na
var float        sampleDev   = na

// Identify if `n` bars have passed.
if bar_index % n == 0
    // Update the queue.
    sourceArray.push(sourceInput)
    sourceArray.shift()
    // Update the mean and standard deviaiton values.
    sampleMean := sourceArray.avg()
    sampleDev  := sourceArray.stdev() * multiplier

// Calculate band values.
float highBand = sampleMean + sampleDev
float lowBand  = sampleMean - sampleDev

plot(sampleMean, "Basis", color.orange)
plot(highBand, "Upper", color.lime)
plot(lowBand, "Lower", color.red)

Đổi thành:

`pine //@version=5 chỉ số ((Custom Sample BB, overlay = true)

float sourceInput = input.source ((close, Source) int samplesInput = input.int(20, Samples) int n = input.int ((10, Bars) float multiplier = input.float ((2.0, StdDev)

var mảng chua

Nhiều hơn nữa