Gerbang sisi tunggal dari strategi pergeseran grid (notebook)

Gerbang sisi tunggal dari strategi pergeseran grid (notebook)

Perkenalan Strategi - Grid dapat menyesuaikan arah - Pertama-tama membeli dan kemudian jual: Grid akan mulai dari harga awal untuk menggantung invoice ke bawah, dengan setiap interval pembayaran. Perbedaan harga ini adalah parameter, jumlah invoice yang digantung adalah jumlah pensil yang digantung, cukup untuk digantung. Jumlah total invoice yang digantung. - Beli setelah dijual: Operasi yang sebaliknya. - Risiko strategi terbesar adalah pasar unilateral, dimana harga bergeser di luar batas grid. - Grid dengan stop loss otomatis dan fungsi mobile

• ### Komentar:

Strategi ini menggunakan desain virtual pending yang sangat baik untuk mempermudah penanganan dan meringankan masalah dengan membatasi jumlah pending di bursa.

Desain grid logisnya fleksibel dan terstruktur dengan baik.

Perhitungan laba rugi, berbagai angka statistik Algoritma dapat diambil, berbagai kondisi mendeteksi desain yang ketat.

Sumber-kode sangat berharga untuk dipelajari.

• ### #Kode komentar

Tidak. /* Parameter antarmuka (diwakili dalam kode sebagai variabel global) Variabel Deskripsi Tipe Default
OpType Arah kisi Unduh kotak unduh ((selected) Membeli sebelum menjual Membeli sebelum menjual FirstPriceAuto Harga pertama otomatis Bulu (true/false) true FirstPrice @!FirstPriceAuto Harga pertama bernomor 100 AllNum Jumlah total Jenis digit (number) 10 PriceGrid interval harga tipe angka 1 PriceDiff Perbedaan harga (EUR) Jenis angka (NOMBER) 2 AmountType Ukuran pesanan Goresan kotak ((selected) Beli dan jual dengan jumlah yang sama AmountOnce@AmountType==0 Jumlah uang kertas berangka (number) 0.1 BAmountOnce@AmountType==1 Ukuran pembayaran Jenis numerik (number) 0.1 SAmountOnce@AmountType==1 dijual satu ukuran ukuran numerik ((number) 0.1 AmountCoefficient@AmountType== 0 perbedaan jumlah string ((string) *1 AmountDot Skala bilangan kecil Digit terpanjang (number) 3 EnableProtectDiff Aktifkan perlindungan perbedaan harga Bulu (true/false) false ProtectDiff @ EnableProtectDiff Ke dalam pasar harga perlindungan negatif tipe digital ((number) 20) CancelAllWS Hapus semua daftar gantung saat dihentikan CheckInterval Interval pencarian berangka digit (number) 2000 Interval gagal uji ulang Interval numerik (number) 1300 RestoreProfit Mengembalikan keuntungan terakhir Bull (true/false) false LastProfit @RestoreProfit Keuntungan terakhir ProfitAsOrg@RestoreProfit Keuntungan terakhir dihitung pada harga rata-rata Bull tipe ((true/false) false EnableAccountCheck Mengaktifkan pemeriksaan dana True/false true EnableStopLoss @ EnableAccountCheck Mengaktifkan stop loss Bulu ((true/false) false StopLoss @EnableStopLoss Maksimum kerugian terapung (Yun) Format angka (Nomor) 100 StopLossMode @EnableStopLoss Operasi setelah stop loss Turunkan kotak ((selected) untuk mendaur ulang dan keluar dari daur ulang EnableStopWin @EnableAccountCheck Mengaktifkan StopWin Bulu (true/false) false StopWin @EnableStopWin Keuntungan Terapung Maksimal (Yun) Format (Nomor) 120 StopWinMode @EnableStopWin Operasi setelah berhenti berlari Turunkan kotak ((selected) Daur Ulang dan keluar dari Daur Ulang AutoMove@EnableAccountCheck Otomatis bergerak Bulu (true/false) false MaxDistance@AutoMove Jarak maksimum (%) Nomor (%) 20 MaxIdle@AutoMove Maksimal ruang kosong ((detik) Nomor 7200 EnableDynamic Buka daftar gantung dinamis Bulu (true/false) false DynamicMax@EnableDynamic Perintah gagal jarak (s) angka (s) nomor (s) 30 ResetData Menghilangkan semua data pada saat startup Bulu (true/false) true Precision Harga kecil panjang digit (number) 5 */

function hasOrder ((orders, orderId) { // Mengidentifikasi apakah ada ID untuk orderId dalam parameter orders for (var i = 0; i < orders.length; i++) { // Menelusuri orders Mengidentifikasi apakah ada id yang sama dan menemukan kembali true if (orders[i].Id == orderId) { Kembali benar; Aku tidak tahu. Aku tidak tahu. return false; // Setelah melalui semua, tanpa memicu if, tidak menemukan ID untuk orderId, kembali false Aku tidak tahu.

function cancelPending (() { // Batalkan semua daftar gantung fungsi var ret = false; // setting Kembali sukses Variabel penanda while (true) { // while lingkaran if (ret) { // jika ret adalah benar, Sleep untuk waktu tertentu Sleep (Interval); Aku tidak tahu. var orders = _C ((exchange.GetOrders); // Panggilan API Dapatkan informasi pesanan yang belum selesai if (orders.length == 0) { // Jika dikembalikan adalah set kosong, maka tidak ada pesanan yang belum selesai di bursa. break; // melompat keluar dari loop while Aku tidak tahu.

    for (var j = 0; j < orders.length; j++) {               // 遍历 未完成的 订单数组， 并根据索引j 逐个使用  orders[j].Id 去 取消订单。
        exchange.CancelOrder(orders[j].Id, orders[j]);
        ret = true;                                         // 一旦有取消操作， ret 赋值 为 true 。用于触发 以上 Sleep ， 等待后重新 exchange.GetOrders 检测 
    }
}
return ret;                                                 // 返回 ret

}

function valuesToString ((values, pos) { // nilai Konversi menjadi string var result = ; // Mengisyaratkan string kosong yang digunakan untuk mengembalikan result if (typeof(pos) === undefined) { // Jika tidak ada parameter pos yang ditransfer, pos diberi nilai 0 Pos = 0; Aku tidak tahu. for (var i = pos; i < values.length; i++) { // Arsitektur berdasarkan nilai pos yang diproses if (i > pos) { // Tambahkan ruang kosong setelah string hasil setelah loop pertama kecuali Hasilnya += ; Aku tidak tahu. if (values[i] === null) { // Jika nilai (fungsi) daftar parameter Array) elemen indeks saat ini adalah null maka result ditambahkan null string hasil + = null; } else if (typeof(values[i]) == undefined) { // Jika tidak didefinisikan, tambahkan undefined result += filter undefined filter; } else { // tipe sisa melakukan switch deteksi pemrosesan switch (values[i].constructor.name) { // Memeriksa atribut name dari constructor values[i, yaitu nama tipe Tombol case: Kasus Nomor Jika tidak, Anda tidak akan dapat mengaksesnya. Fungsi Fungsi: result += values[i].toString(); // Jika tipe tanggal, tipe nilai, tipe string, tipe fungsi, panggil fungsi toString. "Mengenai apa yang terjadi?" default: result += JSON.stringify ((values[i]); // dalam kasus lain menggunakan fungsi JSON.stringify Mengkonversi ke string JSON Ditambahkan ke result "Mengenai apa yang terjadi?" Aku tidak tahu. Aku tidak tahu. Aku tidak tahu. return result; // Kembali hasil Aku tidak tahu.

function Trader ((() { // Trader Fungsi, menggunakan penutupan. var vId = 0; // ID peningkatan pesanan var orderBooks = []; // Pemesanan kecil var hisBooks = []; // Perintah sejarah tipis var orderBooksLen = 0; // panjang order tipis this.Buy = function ((price, amount, extra) { // Fungsi beli, parameter: harga 、 kuantitas 、 informasi ekstensi if (typeof ((extra) === undefined) { // Jika parameter extra tidak ditransfer, typeof kembali undefined extra = ; // memberi extra nilai pada string kosong } lainnya { extra = valuesToString ((arguments, 2); // Untuk memanggil fungsi this.Buy, arguments parameter yang dikirimkan ke dalam fungsi valuesToString Aku tidak tahu. vId++; // var orderId = V + vId; // orderBooks[orderId] = { // Tambahkan properti orderId ke dalam arithmetic orderthin untuk inisialisasi objek yang dibuat. Type: ORDER_TYPE_BUY, // obyek yang dibangun Type atribut: tipe Pembayaran Status: ORDER_STATE_PENDING, // status Ditunda Id: 0, // ID pesanan 0 Harga: harga, // harga parameter harga Amount: amount, // jumlah pesanan parameter amount Extra: extra // informasi ekstensi string yang diproses oleh valuesToString. Aku tidak tahu. orderBooksLen++; // panjang order tipis return orderId; // Mengembalikan orderId dari order yang dibuat pada saat ini (tidak harus dikelirukan dengan orderID bursa). Aku tidak tahu. this.Sell = function ((price, amount, extra) { // dan thie.Buy pada dasarnya mirip, membangun order jual. if (typeof ((extra) === undefined) { extra = ; } lainnya { extra = valuesToString ((arguments, 2)); Aku tidak tahu. vId++; var orderId = V + vId; orderBooks[orderId] = { Type: ORDER_TYPE_SELL Status: ORDER_STATE_PENDING Id: 0, Harga: harga, Jumlah: jumlah, Extra: ekstra Aku tidak tahu. orderBooksLen++; return orderId; Aku tidak tahu. this.GetOrders = function() { // Mengambil informasi pesanan yang belum selesai var orders = _C ((exchange.GetOrders); // Panggilan API GetOrders Mengambil informasi pesanan yang belum selesai Atur nilai untuk order for (orderId in orderBooks) { // menelusuri orderBooks dalam objek Trader var order = orderBooks[orderId]; // Mengambil order berdasarkan orderId if (order.Status!== ORDER_STATE_PENDING) { // Jika status order tidak sama dengan status hang, skip loop ini Teruskan; Aku tidak tahu. var found = false; // initialize found Variable (menandai apakah ditemukan) to true for (var i = 0; i < orders.length; i++) { // Melalui API untuk mengembalikan data pesanan yang belum selesai
if (orders[i].Id == order.Id) { // Untuk menemukan dan tidak menyelesaikan order di orderBooks, id yang sama dengan order, memberikan found nilai true, mewakili menemukan. found = true;
break; // melompat keluar dari loop saat ini Aku tidak tahu. Aku tidak tahu. if (!found) { // Jika tidak ditemukan, push orders ke orderBooks[orderId]。 orders.push ((orderBooks[orderId]); // Mengapa mendorong seperti ini? Aku tidak tahu. Aku tidak tahu. return orders; // Mengembalikan order Aku tidak tahu. this.GetOrder = function ((orderId) { // Dapatkan pesanan if (typeof ((orderId) === numberId) { // jika parameter orderId yang dikirim adalah tipe angka return exchange.GetOrder ((orderId); // Panggilan API GetOrder Mengambil informasi pesanan berdasarkan orderId dan mengembalikannya. Aku tidak tahu. if (typeof ((hisBooks[orderId])!== undefined) { // typeof ((hisBooks[orderId]) Jika tidak sama dengan Tidak didefinisikan return hisBooks[orderId]; // Mengembalikan data dari properti orderId di hisBooks Aku tidak tahu. if (typeof ((orderBooks[orderId])!== undefined) { // Selain itu, orderBooks akan mengembalikan data ini jika ada atribut yang memiliki nilai orderId. return orderBooks[orderId]; Aku tidak tahu. return null; // Kembali null jika tidak memenuhi kondisi di atas Aku tidak tahu. this.Len = function() { // Mengembalikan variabel orderBookLen dari Trader, yaitu panjang tipis order. return orderBooksLen; Aku tidak tahu. this.RealLen = function() { // Kembali jumlah order yang diaktifkan di dalam order. var n = 0; // Penghitungan awal adalah 0 for (orderId in orderBooks) { // Menelusuri order if (orderBooks[orderId].Id > 0) { // Jika Id dari order saat ini dalam perjalanan lebih besar dari 0, yaitu 0 pada waktu non-awal, itu menunjukkan bahwa order telah dipesan, dan itu telah diaktifkan. n++; // Kumulatif Pemesanan yang sudah diaktifkan Aku tidak tahu. Aku tidak tahu. return n; // Mengembalikan nilai n, yaitu mengembalikan true Order thin length. Aku tidak tahu. this.Poll = function ((ticker, priceDiff) { // var orders = _C ((exchange.GetOrders); // Dapatkan semua pesanan yang belum selesai for (orderId in orderBooks) { // Menelusuri order var order = orderBooks[orderId]; // Mengambil order saat ini Atur nilai ke order if (order.Id > 0) { // Jika order adalah status aktif, maka order.Id tidak 0 (sebelumnya sudah dipesan) var found = false; // variabel found (menandai ditemukan) adalah false for (var i = 0; i < orders.length; i++) { // Menemukan nomor pesanan yang sama dalam informasi order yang belum selesai yang dikembalikan oleh bursa if (order.Id == orders[i].Id) { // Jika pencarian ditemukan, berikan found nilai true, yang berarti telah ditemukan. found = true; Aku tidak tahu. Aku tidak tahu. if (!found) { // Jika order yang mewakili orderId saat ini tidak ditemukan dalam order array yang belum selesai yang dikembalikan oleh bursa. order.Status = ORDER_STATE_CLOSED; // Diperbarui untuk orderId yang sesuai dalam orderBooks (misalnya variabel order saat ini), Status properti diperbarui menjadi ORDER_STATE_CLOSED (misalnya ditutup) hisBooks[orderId] = order; // order yang selesai Dicatat dalam daftar order historis, yaitu hisBooks, dengan nomor orderId yang seragam dan unik delete ((orderBooks[orderId]); // Hapus Atribut orderthin yang diberi nama orderId,.. orderBooksLen; // order tipis Continue; // kode di bawah ini untuk melewatkan loop lanjutkan. Aku tidak tahu. Aku tidak tahu. var diff = _N ((order.Type == ORDER_TYPE_BUY? (ticker.Buy - order.Price) : (order.Price - ticker.Sell)); // diff adalah perbedaan antara harga awal yang direncanakan dan harga awal saat ini.

        var pfn = order.Type == ORDER_TYPE_BUY ? exchange.Buy : exchange.Sell;   // 根据订单的类型，给 pfn 赋值相应的  API 函数 引用。
        // 即 如果 order 的类型是买单 ， pfn 就是  exchange.Buy 函数的引用， 卖单同理。

        if (order.Id == 0 && diff <= priceDiff) {                                // 如果 订单薄中的订单 order 没有激活（即Id 等于0 ） 并且 当前价格距离 订单计划价格 小于等于 参数传入的 priceDiff
            var realId = pfn(order.Price, order.Amount, order.Extra + "(距离: " + diff + (order.Type == ORDER_TYPE_BUY ? (" 买一: " + ticker.Buy) : (" 卖一: " + ticker.Sell))+")");
            // 执行下单函数 ，参数传入 价格、数量、 订单扩展信息 + 挂单距离 + 行情数据（买一 或者 卖一），返回 交易所 订单id

            if (typeof(realId) === 'number') {    // 如果 返回的  realId 是数值类型
                order.Id = realId;                // 赋值给 订单薄 当前的订单  order的 Id 属性。
            }
        } else if (order.Id > 0 && diff > (priceDiff + 1)) {  // 如果订单 处于激活状态， 并且 当前距离 大于 参数传入的 距离
            var ok = true;                                    // 声明一个 用于标记的变量   初始 true 
            do {                                              // 先执行 do 再判断 while
                ok = true;                                    // ok 赋值 true
                exchange.CancelOrder(order.Id, "不必要的" + (order.Type == ORDER_TYPE_BUY ? "买单" : "卖单"), "委托价:", order.Price, "量:", order.Amount, ", 距离:", diff, order.Type == ORDER_TYPE_BUY ? ("买一: " + ticker.Buy) : ("卖一: " + ticker.Sell));
                // 取消 当前 超出 范围的挂单， 在取消订单这条日志后 打印 当前订单的信息、当前 距离 diff。

                Sleep(200);                                   // 等待 200 毫秒
                orders = _C(exchange.GetOrders);              // 调用 API 获取 交易所 中 未完成的订单。
                for (var i = 0; i < orders.length; i++) {     // 遍历 这些未完成的订单。
                    if (orders[i].Id == order.Id) {           // 如果找到 取消的订单 还在 交易所未完成的订单数组中
                        ok = false;                           // 给 ok 这个变量赋值 false ， 即没有 取消成功
                    }
                }
            } while (!ok);                                    // 如果 ok 为 false，则 !ok 为 true ，while 就会继续重复循环，继续取消这个订单，并检测是否取消成功
            order.Id = 0;                                     // 给 order.Id 赋值 0 , 代表 当前这个订单 是未激活的。
        }
    }
};

}

function balanceAccount ((orgAccount, initAccount) { // Balance account Fungsi Parameter Kebijakan Informasi akun awal pada saat startup, Informasi akun awal sebelum jaringan ini cancelPending ((); // Mengundang fungsi kustom cancelPending (() untuk membatalkan semua daftar tertunda. var nowAccount = _C ((exchange.GetAccount); // Mengisyaratkan variabel nowAccount untuk mencatat informasi terbaru tentang akun saat ini. var slidePrice = 0.2; // SlidePrice saat melakukan pesanan ditetapkan menjadi 0.2 var ok = true; // Variabel yang ditandai awal true while (true) { // while lingkaran var diff = _N ((nowAccount.Stocks - initAccount.Stocks); // Menghitung perbedaan mata uang antara akun saat ini dan akun awal if (Math.abs(diff) < exchange.GetMinStock()) { // Jika nilai mutlak dari perbedaan mata uang lebih kecil dari volume perdagangan minimum di bursa, break keluar dari lingkaran dan tidak melakukan operasi rebalancing. "Mengenai apa?" Aku tidak tahu. var depth = _C ((exchange.GetDepth); // Dapatkan informasi kedalaman bursa Atur nilai ke variabel depth yang dinyatakan var books = diff > 0? depth.Bids : depth.Asks; // Mengambil dari array bid atau sell di depth berdasarkan perbedaan mata uang yang lebih besar dari 0 atau lebih kecil dari 0 Jika Anda ingin menjual saldo, maka Anda harus melihat array pembayaran, dan jika Anda ingin menjual saldo, Anda harus melihat bahwa Anda memiliki imbalan lebih besar dari 0. var n = 0; // menyatakan bahwa n awalnya adalah 0 var price = 0; // deklarasi harga awal 0 for (var i = 0; i < books.length; i++) { // Menelusuri Pemesanan atau Penjualan Array n += books[i].Amount; // Jumlah total pesanan berdasarkan indeks i yang ditelusuri if (n >= Math.abs ((diff)) { // Jika jumlah pesanan n yang terkumpul lebih besar dari atau sama dengan perbedaan mata uang, maka: price = books[i].Price; // Dapatkan harga dari order dalam indeks saat ini, memberikan nilai untuk price break; // melompat keluar dari loop for saat ini Aku tidak tahu. Aku tidak tahu. var pfn = diff > 0? exchange.Sell : exchange.Buy; // Tergantung pada perbedaan mata uang lebih besar dari 0 atau lebih kecil dari 0, referensi API (exchange.Sell) atau API (exchange.Buy) akan dikirim ke pfn yang dinyatakan var amount = Math.abs ((diff); // Jumlah subunit operasi yang akan diimbangi adalah diff, atau selisih mata uang, yang memberikan nilai pada variabel amount yang dinyatakan var price = diff > 0? (price - slidePrice) : (price + slidePrice); // Berdasarkan arah jual yang ditentukan oleh selisih mata uang, berdasarkan harga, naik atau turunkan harga geser (slide price adalah untuk transaksi yang lebih mudah), lalu atributkan ke harga Log (mengacu pada saldo, (diff > 0? Nilai jual: nilai pembelian), jumlah, nilai saldo); // Menghasilkan jumlah koin yang ada dalam saldo log. if (diff > 0) { // Mengamati jumlah koin atau jumlah uang yang cukup berdasarkan arah jual beli yang ditentukan oleh perbedaan mata uang. amount = Math.min ((nowAccount.Stocks, amount); // Pastikan jumlah yang akan dikirim tidak melebihi jumlah koin yang tersedia di akun saat ini. } lainnya { amount = Math.min ((nowAccount.Balance / price, amount); // Pastikan jumlah yang akan datang tidak melebihi jumlah uang yang tersedia di akun saat ini. Aku tidak tahu. if (amount < exchange.GetMinStock()) { // Mendeteksi apakah jumlah pesanan akhir lebih kecil dari jumlah pesanan minimum yang diizinkan oleh bursa Log (tidak cukup dana, tidak dapat menyeimbangkan ke status awal); // Jika jumlah subunit terlalu kecil, cetak informasi. ok = false; // ditandai gagal keseimbangan break; // melompat keluar dari loop while Aku tidak tahu. pfn ((price, amount); // Melakukan submenu API (referensi pfn) Sleep ((1000); // Hentikan 1 detik cancelPending ((); // Batalkan semua daftar tertunda. nowAccount = _C ((exchange.GetAccount); // Dapatkan informasi akun terbaru saat ini Aku tidak tahu. if (ok) { // Mengeksekusi kode dalam tanda kurung ketika ok adalah benar (kesuksesan keseimbangan) LogProfit ((_N ((nowAccount.Balance - orgAccount.Balance)); // Menggunakan parameter orgAccount yang ditransfer (informasi akun sebelum imbangan) untuk atribut Balance Mengurangi atribut Balance dari informasi akun saat ini, yaitu selisih jumlah uang, Jika kita tidak memiliki jumlah koin yang sama, maka kita tidak akan memiliki jumlah koin yang sama. Log (mengacu pada saldo selesai, nowAccount); // Menghasilkan log Balance selesai. Aku tidak tahu. Aku tidak tahu.

var STATE_WAIT_OPEN = 0; // Digunakan untuk status setiap node di fishTable Var STATE_WAIT_COVER = 1; //... var STATE_WAIT_CLOSE = 2; //... var ProfitCount = 0; // Jumlah keuntungan dan kerugian var BuyFirst = true; // awal Parameter antarmuka var IsSupportGetOrder = true; // Apakah bursa mendukung fungsi GetOrder API, variabel global, digunakan untuk menentukan awal fungsi main var LastBusy = 0; // Mencatat terakhir kali obyek waktu yang diproses

function setBusy() { // Mengatur waktu Busy LastBusy = new Date ((); // memberikan LastBusy nilai untuk objek waktu saat ini Aku tidak tahu.

function isTimeout (() { // Mengetahui apakah waktu sudah habis if (MaxIdle <= 0) { // Maksimal waktu kosong ((berdasarkan apakah otomatis ) return false; // mengembalikan false, tidak menilai waktu yang berlalu. Aku tidak tahu. var now = new Date ((); // Dapatkan objek waktu saat ini if (((now.getTime() - LastBusy.getTime()) / 1000) >= MaxIdle) { // Menggunakan fungsi getTime untuk objek waktu saat ini Mengambil timestamp dengan timestamp LastBusy Menghitung perbedaan, // Berbeda detik antara dua objek waktu dibagi dengan 1000. Mengetahui apakah waktu kosong maksimum lebih besar dari MaxIdle LastBusy = now; // Jika lebih besar, update LastBusy untuk obyek waktu sekarang return true; // mengembalikan true, yaitu waktu yang berlalu. Aku tidak tahu. return false; // mengembalikan false Tidak terlambat Aku tidak tahu.

function onexit (() { // Fungsi akhir pada saat program keluar. if (CancelAllWS) { // Setel untuk membatalkan semua daftar pada saat berhenti, maka panggil fungsi cancelPending() Log (yang sedang keluar, mencoba menghapus semua tautan); cancel Pending (((); Aku tidak tahu. Log (Strategi penggelapan berhasil menghentikan penggelapan); Log ((_C ((exchange.GetAccount)); // Mencetak informasi penyimpanan akun saat keluar. Aku tidak tahu.

function fishing ((orgAccount, fishCount) { // Parameter: Informasi akun, jumlah pelayaran setBusy(); // Mengatur LastBuys sebagai timestamp saat ini var account = _C ((exchange.GetAccount); // Mengisyaratkan variabel account, mendapatkan informasi akun saat ini dan memberi nilai. Log ((account); // Menghasilkan informasi akun saat ini memanggil fungsi fishing. var InitAccount = account; // Mengisyaratkan variabel InitAccount dan menggunakan nilai account. Ini adalah catatan dana akun awal sebelum ini. var ticker = _C ((exchange.GetTicker); // Dapatkan perilaku Atur nilai ke variabel ticker yang dinyatakan var amount = _N ((AmountOnce); // Menggunakan _N untuk menangani bilangan kecil ((_N secara default menyimpan 2 digit) berdasarkan parameter antarmuka Jumlah tunggal), memberikan nilai untuk jumlah. var amountB = [amount]; // menyatakan suatu variabel yang disebut amountB adalah suatu array yang menginisialisasi suatu elemen dengan amount var amountS = [amount]; // menyatakan variabel yang disebut amountS... if (typeof(AmountType)!== undefined && AmountType == 1) { // Dengan ukuran pesanan, ukuran pesanan, dan tipe yang disesuaikan. // dan AmountType diatur pada antarmuka sebagai jumlah kustom, yaitu nilai AmountType adalah 1 (indeks dropbox) for (var idx = 0; idx < AllNum; idx++) { // AllNum. Jumlah total. Jika ditetapkan jumlah kustom, berdasarkan jumlah total. amountB[idx] = BAmountOnce; // Menggunakan parameter antarmuka Untuk memberikan jumlah pembayaran amountS[idx] = SAmountOnce; //... memberikan pesanan untuk dijual... Aku tidak tahu. } else { // lainnya for (var idx = 1; idx < AllNum; idx++) { // Berdasarkan jumlah total kisi loop ⋅ switch (AmountCoefficient[0]) { // Perbedaan berdasarkan parameter antarmuka Karakter pertama dari string ini, yaitu AmountCoefficient[0], adalah +, -, "Mengharukan" case + : // Menggunakan parameter antarmuka untuk membangun grid yang ditingkatkan dengan penjumlahan subunit. amountB[idx] = amountB[idx - 1] + parseFloat ((AmountCoefficient.substring ((1)); "Mengenai apa yang terjadi?" case -: //... amountB[idx] = amountB[idx - 1] - parseFloat ((AmountCoefficient.substring ((1)); "Mengenai apa yang terjadi?" kasus Apa yang terjadi? jumlahB[idx] = jumlahB[idx - 1] * parseFloat ((AmountCoefficient.substring)))); "Mengenai apa yang terjadi?" Dalam kasus ini: amountB[idx] = amountB[idx - 1] / parseFloat ((AmountCoefficient.substring ((1)); "Mengenai apa yang terjadi?" Aku tidak tahu. amountB[idx] = _N ((amountB[idx], AmountDot); // pembayaran 、 pembayaran Jumlah yang sama, memproses data bilangan kecil. jumlahS[idx] = jumlahB[idx]; // memberikan nilai. Aku tidak tahu. Aku tidak tahu. if (FirstPriceAuto) { // Jika parameter antarmuka diatur Harga pertama otomatis menjadi benar, menjalankan kode if dalam tanda kurung. FirstPrice = BuyFirst? _N ((ticker.Buy - PriceGrid, Precision) : _N ((ticker.Sell + PriceGrid, Precision); // Parameter antarmuka FirstPrice Mengatur harga pertama berdasarkan variabel global BuyFirst (diproklamasikan awal sebagai benar, pada awal main sudah berdasarkan penugasan OpType) dengan menggunakan ticker pasar saat ini dan parameter antarmuka PriceGrid untuk mengatur rentang harga. Aku tidak tahu. // Initialize fish table Inisialisasi kisi var fishTable = {}; // Mengisyaratkan objek kisi var uuidTable = {}; // Kode identifikasi objek tabel var needStocks = 0; // Jumlah koin yang dibutuhkan Variabel var needMoney = 0; // uang yang dibutuhkan variabel var actualNeedMoney = 0; // uang yang sebenarnya dibutuhkan var actualNeedStocks = 0; // Mata uang yang sebenarnya dibutuhkan var notEnough = false; // Tidak cukup dana Variabel yang ditandai, awalnya ditetapkan sebagai false var canNum = 0; // tersedia for (var idx = 0; idx < AllNum; idx++) { // Mengikuti AllNum berdasarkan jumlah kisi. var price = _N (((BuyFirst? FirstPrice - (idx * PriceGrid) : FirstPrice + (idx * PriceGrid)), Precision); // Saat berjalan di seluruh konstruksi, harga indeks idx saat ini diatur berdasarkan BuyFirst. Jarak antara setiap harga indeks adalah PriceGrid. needStocks += amountS[idx]; // jumlah koin yang dibutuhkan untuk dijual. needMoney += price * amountB[idx]; // jumlah uang yang dibutuhkan untuk pembelian. if (BuyFirst) { // Proseskan sebelum membeli if (_N(needMoney) <= _N(account.Balance)) { // Jika jumlah uang yang dibutuhkan jaringan kurang dari jumlah uang yang tersedia di akun actualNeedMondy = needMoney; // memberikan nilai untuk jumlah uang yang sebenarnya dibutuhkan actualNeedStocks = needStocks; // memberikan nilai untuk jumlah koin yang sebenarnya dibutuhkan. canNum++; // Jumlah grid yang tersedia } else { // _N ((needMoney) <= _N ((account.Balance) Kondisi ini tidak terpenuhi, maka variabel yang ditandai sebagai true ditetapkan sebagai tidak cukup dana notEnough = true; Aku tidak tahu. } else { // Pengolahan sebelum penjualan if (_N(needStocks) <= _N(account.Stocks)) { // Mengidentifikasi apakah jumlah koin yang dibutuhkan kurang dari jumlah koin yang tersedia di akun realNeedMondy = needMoney; // penentuan nilai Saat ini, saya sedang mencari solusi untuk masalah ini. canNum++; // Jumlah grid yang tersedia } lainnya { notEnough = true; // Jika kondisi dana tidak terpenuhi, atur true Aku tidak tahu. Aku tidak tahu. fishTable[idx] = STATE_WAIT_OPEN; // Berdasarkan indeks idx saat ini, status anggota idx dari objek grid (grid node) yang ditetapkan, dimulai dengan STATE_WAIT_OPEN (waiting to open) uuidTable[idx] = -1; // Objek bernomor juga berdasarkan pada inisialisasi idx saat ini. Nilai idx sendiri (yang sesuai dengan node fishTable) adalah -1 Aku tidak tahu. if (!EnableAccountCheck && (canNum ProtectDiff) { // Aktifkan Perlindungan Perbedaan dan Turunkan Harga throw adalah harga pertama yang dibeli dibandingkan dengan harga pertama yang dijual di pasar. } else if (EnableAccountCheck && account.Balance < _N(needMoney)) { // Jika cek dana diaktifkan dan jumlah uang yang tersedia di akun kurang dari jumlah uang yang dibutuhkan oleh grid}. if (fishCount == 1) { // Jika pertama kali menyaring throw tidak cukup dana, membutuhkan + _N ((needMoney) + ; // membuang kesalahan tidak cukup dana } lainnya { Log (tidak cukup dana, perlu uang, _N (needMoney), Yuan, program hanya melakukan uang, canNum, #ff0000) Aku tidak tahu. } else { // lainnya, tidak diaktifkan Pemeriksaan dana, perlindungan harga, dll. Log (( diperkirakan uang muka: , _N ((needMoney), Yuan Yuan); // output diperkirakan uang muka。 Aku tidak tahu. } else { // jual dulu, beli dulu if (EnableProtectDiff && (ticker.Buy - FirstPrice) > ProtectDiff) { Throw Tick pertama kali menjual lebih tinggi dari harga jual 1 Tick + _N (ticker.Buy - FirstPrice, Precision) + Tick Yuan; } else if (EnableAccountCheck && account.Stocks < _N(needStocks)) { if (fishCount == 1) { Jika Anda tidak memiliki cukup koin, maka Anda harus menggunakan koin + _N (needStocks) + koin. } lainnya { Log (tidak cukup dana, perlu saham, _N (needStocks), koin, program hanya membuat saham, canNum, grid #ff0000); Aku tidak tahu. } lainnya { Log (menentukan jumlah koin yang akan digunakan: _N (needStocks), _N (needMoney), _N (needStocks), _N (needMoney), _N (needStocks), _N (needStocks)); Aku tidak tahu. Aku tidak tahu.

var trader = new Trader();                                          // 构造一个 Trader 对象， 赋值给 此处声明的 trader 变量。
var OpenFunc = BuyFirst ? exchange.Buy : exchange.Sell;             // 根据 是否先买后卖 ，设定开仓函数OpenFunc 是 引用 exchange.Buy 还是 exchange.Sell
var CoverFunc = BuyFirst ? exchange.Sell : exchange.Buy;            // 同上
if (EnableDynamic) {                                                // 根据界面参数 EnableDynamic (是否动态挂单) 是否开启， 去再次 设定 OpenFunc/CoverFunc
    OpenFunc = BuyFirst ? trader.Buy : trader.Sell;                 // 引用 trader 对象的 成员函数 Buy 用于 动态挂单 （主要是由于一些交易所 限制挂单数量，所以就需要虚拟动态挂单）
    CoverFunc = BuyFirst ? trader.Sell : trader.Buy;                // 同上
}
var ts = new Date();                                                // 创建此刻时间对象（赋值给ts），用于记录此刻时间。
var preMsg = "";                                                    // 声明一个 变量 用于记录 上次信息， 初始 空字符串
var profitMax = 0;                                                  // 最大收益 
while (true) {                                                      // 网格 撒网后的 主要 逻辑
    var now = new Date();                                           // 记录 当前循环 开始的时的时间
    var table = null;                                               // 声明一个 变量
    if (now.getTime() - ts.getTime() > 5000) {                      // 计算当前 时间 now 和 记录的时间 ts 之间的差值 是否大于 5000 毫秒
        if (typeof(GetCommand) == 'function' && GetCommand() == "收网") {         // 检测是否 接收到 策略 交互控件 命令  “收网”，停止并平衡到初始状态
            Log("开始执行命令进行收网操作");                                          // 输出 信息 
            balanceAccount(orgAccount, InitAccount);                              // 执行平衡函数 ，平衡币数 到初始状态
            return false;                                                         // 本次 撒网函数  fishing 返回 false
        }
        ts = now;                                                                 // 用当前时间 now 更新 ts，用于下次比对时间
        var nowAccount = _C(exchange.GetAccount);                                 // 声明 nowAccount 变量  并初始为当前最新 账户信息。
        var ticker = _C(exchange.GetTicker);                                      // 声明 ticker 变量 并初始为当前行情信息
        if (EnableDynamic) {                                                      // 如果开启动态挂单
            trader.Poll(ticker, DynamicMax);                                      // 调用 trader 对象的 Poll 函数 ，根据 当前 ticker 行情，和 界面参数 DynamicMax（订单失效距离）检测 并 处理 所有订单。
        }
        var amount_diff = (nowAccount.Stocks + nowAccount.FrozenStocks) - (InitAccount.Stocks + InitAccount.FrozenStocks);  // 计算当前的 币差
        var money_diff = (nowAccount.Balance + nowAccount.FrozenBalance) - (InitAccount.Balance + InitAccount.FrozenBalance); // 计算当前的 钱差
        var floatProfit = _N(money_diff + (amount_diff * ticker.Last));           // 计算 当前 本次撒网 的浮动盈亏
        var floatProfitAll = _N((nowAccount.Balance + nowAccount.FrozenBalance - orgAccount.Balance - orgAccount.FrozenBalance) + ((nowAccount.Stocks + nowAccount.FrozenStocks - orgAccount.Stocks - orgAccount.FrozenStocks) * ticker.Last));
        // 计算 总体的浮动盈亏

        var isHold = Math.abs(amount_diff) >= exchange.GetMinStock();             // 如果 此刻 币差 绝对值 大于 交易所最小 交易量 ，代表已经持仓
        if (isHold) {                                                             // 已经持仓 则执行  setBusy() 函数，该函数会给 LastBusy 更新时间。
            setBusy();                                                            // 即  开仓后开始  启动开仓机制。
        }

        profitMax = Math.max(floatProfit, profitMax);                             // 刷新 最大浮动盈亏
        if (EnableAccountCheck && EnableStopLoss) {                               // 如果启动账户检测 并且 启动 止损
            if ((profitMax - floatProfit) >= StopLoss) {                          // 如果 最大浮动盈亏 减去 当前浮动盈亏 大于等于 最大浮动亏损值，则执行 花括号内代码
                Log("当前浮动盈亏", floatProfit, "利润最高点: ", profitMax, "开始止损");   // 输出信息
                balanceAccount(orgAccount, InitAccount);                          // 平衡账户
                if (StopLossMode == 0) {                                          // 根据 止损模式 处理， 如果 StopLossMode 等于 0 ，即 止损后退出程序。
                    throw "止损退出";                                               // 抛出错误 “止损退出”  策略停止。
                } else {
                    return true;                                                   // 除了 止损后退出模式，  即 ： 止损后重新撒网。
                }
            }
        }
        if (EnableAccountCheck && EnableStopWin) {                                 // 如果开启了 检测账户 并且 开启了 止盈
            if (floatProfit > StopWin) {                                           // 如果 浮动盈亏 大于 止盈
                Log("当前浮动盈亏", floatProfit, "开始止盈");                         // 输出日志
                balanceAccount(orgAccount, InitAccount);                           // 平衡账户 恢复初始 （止盈）
                if (StopWinMode == 0) {                                            // 根据止盈模式 处理。
                    throw "止盈退出";                                                // 止盈后退出
                } else {
                    return true;                                                    // 止盈后 返回 true ， 继续撒网
                }
            }
        }
        var distance = 0;                                                           // 声明 一个 变量 用来 记录 距离
        if (EnableAccountCheck && AutoMove) {                                       // 如果开启 账户检测 并且 网格自动移动
            if (BuyFirst) {                                                         // 如果是 先买后卖 
                distance = ticker.Last - FirstPrice;                                // 给 distance 赋值 ： 当前的价格 减去 首价格,算出距离 
            } else {                                                                // 其他情况 ： 先卖后买
                distance = FirstPrice - ticker.Last;                                // 给 distance 赋值 ： 首价格 减去 当前价格，算出距离
            }
            var refish = false;                                                     // 是否重新撒网 标记变量
            if (!isHold && isTimeout()) {                                           // 如果没有持仓（isHold 为 false） 并且 超时（isTimeout 返回 true）
                Log("空仓过久, 开始移动网格");                                         
                refish = true;                                                      // 标记 重新撒网 
            }
            if (distance > MaxDistance) {                                           // 如果 当前 的距离 大于 界面参数设定的最大距离， 标记 重新撒网
                Log("价格超出网格区间过多, 开始移动网格, 当前距离: ", _N(distance, Precision), "当前价格:", ticker.Last);
                refish = true;
            }
            if (refish) {                                                           // 如果 refish 是 true ,则执行 平衡函数 
                balanceAccount(orgAccount, InitAccount);
                return true;                                                        // 本次 撒网函数 返回 true
            }
        }

        var holdDirection, holdAmount = "--",                                       // 声明 三个 变量，持仓方向、持仓数量、持仓价格
            holdPrice = "--";
        if (isHold) {                                                               // 持仓时
            if (RestoreProfit && ProfitAsOrg) {                                     // 如果 开启 恢复上次盈利 并且 上次盈利算入均价
                if (BuyFirst) {                                                     // 如果是先买后卖 
                    money_diff += LastProfit;                                       // 把上次盈利 加入 money_diff ，即 上次收益 折合入 钱差（在先买的情况，钱差为负值，即花费的），折合入开仓成本。
                } else {                                                            // 如果是先卖后买
                    money_diff -= LastProfit;                                       // 先卖后买 钱差 为 正值 , why - ?
                }
            }

            // 处理先买后卖
            holdAmount = amount_diff;                                               // 币差 赋值 给持仓数量 （此刻币差 即 持仓）
            holdPrice = (-money_diff) / amount_diff;                                // 用 钱差 除以 币差 算出 持仓均价， 
                                                                                    // 注意 ： 如果 money_diff 为 负值 ，则amount_diff 一定为正值，所以一定要在 money_diff 前加 负号，这样算出的价格才是 正数
            // 处理先卖后买
            if (!BuyFirst) {                                                        // 如果是 先卖后买 则触发 更新 持仓量 和 持仓均价
                holdAmount = -amount_diff;                                          // 币差为负数  ，所以取反
                holdPrice = (money_diff) / -amount_diff;                            // 计算持仓均价。
            }
            holdAmount = _N(holdAmount, 4);                                         // 持仓量，保留4位小数。
            holdPrice = _N(holdPrice, Precision);                                   // 持仓均价， 保留 Precision 位小数。
            holdDirection = BuyFirst ? "多" : "空";                                  // 根据 先买后卖 或者 先卖后买 给 holdDirection 赋值 多 或者 空
        } else {                                                                    // 如果 isHold 为false ,给holdDirection 赋值 "--"
            holdDirection = "--";
        }
        table = {                                                                   // 给声明 的 table 变量 赋值一个 对象，用于在 发明者量化 机器人 状态栏上显示 表格信息
            type: 'table',                                                          // 详见 API 文档 LogStatus 函数， 这里给 type 属性 初始化 'table' 用于在状态栏显示成表格
            title: '运行状态',                                                        // 表格的 标题
            cols: ['动用资金', '持有仓位', '持仓大小', '持仓均价', '总浮动盈亏', '当前网格盈亏', '撒网次数', '网格偏移', '真实委托', '最新币价'],   // 表格的 列名
            rows: [                                                                                                                   // 表格的 逐行的数据
                [_N(actualNeedMondy, 4), holdDirection, holdAmount, holdPrice, _N(floatProfitAll, 4) + ' ( ' + _N(floatProfitAll * 100 / actualNeedMondy, 4) + ' % )', floatProfit, fishCount, (AutoMove && distance > 0) ? ((BuyFirst ? "向上" : "向下") + "偏离: " + _N(distance) + " 元") : "--", trader.RealLen(), ticker.Last]
                // 一行数据
            ]
        };

    }                                                                               // 每间隔 5 秒处理 一些任务， 并更新 机器人状态栏 表格对象 table 

    var orders = _C(trader.GetOrders);                                              // 获取 所有未完成的订单
    if (table) {                                                                    // 如果 table 已经被 赋值表格对象
        if (!EnableDynamic) {                                                       // 如果没有开启动态挂单
            table.rows[0][8] = orders.length;                                       // 在状态栏 表格 第一行 第9列 位置 更新 挂单数组的长度
        }
        LogStatus('`' + JSON.stringify(table) + '`');                               // 调用 发明者量化 平台 API LogStatus 显示 设置的状态栏表格
    }
    for (var idx = 0; idx < canNum; idx++) {                                        // 遍历 可用的 网格节点数量。
        var openPrice = _N((BuyFirst ? FirstPrice - (idx * PriceGrid) : FirstPrice + (idx * PriceGrid)), Precision);        // 随着 节点 索引 idx 遍历，构造每个节点的 开仓价 （方向由 先买后卖，或者先卖后买 决定） 
        var coverPrice = _N((BuyFirst ? openPrice + PriceDiff : openPrice -