Vela → ឃ្លាំងសម្ងាត់ឆ្លាតវៃសម្រាប់ស៊េរីពេលវេលា និងច្រើនទៀត

នៅក្នុង fintech ជាញឹកញាប់យើងត្រូវដំណើរការទិន្នន័យអត្រាប្តូរប្រាក់យ៉ាងច្រើន។ យើងទទួលបានទិន្នន័យពីប្រភពផ្សេងៗគ្នា ហើយពួកគេម្នាក់ៗមានគំនិតផ្ទាល់ខ្លួនអំពីរបៀបបន្ថែមអត្រាប្តូរប្រាក់សម្រាប់ថ្ងៃស្អែក ថ្ងៃបន្ទាប់ ថ្ងៃស្អែក ខែក្រោយ និងសូម្បីតែបីឆ្នាំបន្ទាប់។ ប្រសិនបើមាននរណាម្នាក់អាចទស្សន៍ទាយអត្រា សិទ្ធិដល់ពេលបិទអាជីវកម្មហើយ ប្តូរលុយទៅវិញទៅមក។ ប្រភពខ្លះអាចទុកចិត្តបានជាង ខ្លះផ្គត់ផ្គង់សំរាមពេញលេញ ជាមួយនឹងការរួមបញ្ចូលដ៏កម្រនៃតម្លៃត្រឹមត្រូវស្ទើរតែទាំងអស់ ប៉ុន្តែសម្រាប់គូស្នេហ៍កម្រនិងអសកម្ម។ ការងាររបស់យើងគឺដើម្បីរុះរើតម្លៃរាប់ម៉ឺនទាំងនេះក្នុងមួយវិនាទី ហើយកំណត់នូវអ្វីដែលត្រូវបង្ហាញដល់អតិថិជន។ យើងត្រូវត្រងចេញនូវតម្លៃត្រឹមត្រូវមួយចេញពីភាពកខ្វក់ និងដីល្បាប់ជាច្រើន ដូចជា flamingos ធ្វើនៅពេលអាហារថ្ងៃត្រង់។

លក្ខណៈពិសេសប្លែករបស់ flamingos គឺចំពុះកោងចុះក្រោមដ៏ធំ ដែលពួកគេត្រងអាហារចេញពីទឹក ឬភក់។
 - វីគី។

ដូច្នេះបណ្ណាល័យបានកើតមក Velaដែលរក្សាទុកឃ្លាំងសម្ងាត់រដ្ឋសម្រាប់តម្លៃច្រើននៅចន្លោះពេលជាក់លាក់។ នៅក្រោមក្រណាត់ វាត្រងទិន្នន័យអាក្រក់ និងហួសសម័យចេញភ្លាមៗ ហើយថែមទាំងផ្តល់នូវការចូលប្រើព័ត៌មានចុងក្រោយបំផុតផងដែរ។ N តម្លៃដែលមានសុពលភាពសម្រាប់កូនសោនីមួយៗ (គូរូបិយប័ណ្ណ ក្នុងករណីរបស់យើង)។

ចូរនិយាយថាយើងប្រមូលអត្រាសម្រាប់គូរូបិយប័ណ្ណបី។ និយមន័យសាមញ្ញបំផុត។ Vela ដើម្បីរក្សាទុកស្ថានភាពបច្ចុប្បន្ន វានឹងមើលទៅដូចនេះ៖

defmodule Pairs do
  use Vela,
    eurusd: [sorter: &Kernel.<=/2],
    eurgbp: [limit: 3, errors: 1],
    eurcad: [validator: Pairs]

  @behaviour Vela.Validator

  @impl Vela.Validator
  def valid?(:eurcad, rate), do: rate > 0
end

ការធ្វើបច្ចុប្បន្នភាពតម្លៃ

Vela.put/3 មុខងារនឹងធ្វើដូចខាងក្រោមតាមលំដាប់លំដោយ៖

• នឹងបណ្តាលឱ្យ validator នៅលើតម្លៃប្រសិនបើមួយត្រូវបានកំណត់ (សូមមើលជំពូក សុពលភាព ខាងក្រោម);
• នឹងបន្ថែមតម្លៃទៅជួរនៃតម្លៃល្អ ប្រសិនបើការផ្ទៀងផ្ទាត់បានជោគជ័យ ឬទៅជួរសេវាកម្ម :__errors__ បើមិនដូច្នេះទេ
• នឹងបណ្តាលឱ្យតម្រៀបប្រសិនបើ sorter បានកំណត់សម្រាប់កូនសោដែលបានផ្តល់ឱ្យ ឬគ្រាន់តែដាក់តម្លៃនៅក្បាលបញ្ជី (LIFOសូមមើលជំពូក តម្រៀប ខាងក្រោម);
• នឹងកាត់ជួរដេកតាមប៉ារ៉ាម៉ែត្រ :limit ឆ្លងកាត់ការបង្កើត;
• នឹងត្រឡប់រចនាសម្ព័ន្ធដែលបានធ្វើបច្ចុប្បន្នភាព Vela.

iex|1 > pairs = %Pairs{}
iex|2 > Vela.put(pairs, :eurcad, 1.0)
#⇒ %Pairs{..., eurcad: [1.0], ...}
iex|3 > Vela.put(pairs, :eurcad, -1.0)
#⇒ %Pairs{__errors__: [eurcad: -1.0], ...}
iex|4 > pairs |> Vela.put(:eurusd, 2.0) |> Vela.put(:eurusd, 1.0)
#⇒ %Pairs{... eurusd: [1.0, 2.0]}

ផងដែរ Vela ឧបករណ៍ប្រើប្រាស់ Accessដូច្នេះអ្នកអាចប្រើមុខងារស្តង់ដារណាមួយសម្រាប់ការធ្វើបច្ចុប្បន្នភាពរចនាសម្ព័ន្ធស៊ីជម្រៅពីឃ្លាំងអាវុធដើម្បីធ្វើបច្ចុប្បន្នភាពតម្លៃ Kernel: Kernel.get_in/2, Kernel.put_in/3, Kernel.update_in/3, Kernel.pop_in/2និង Kernel.get_and_update_in/3.

សុពលភាព

អ្នកបញ្ជាក់អាចកំណត់បានដូចជា៖

• មុខងារខាងក្រៅជាមួយអាគុយម៉ង់មួយ (&MyMod.my_fun/1) វានឹងទទួលបានតែតម្លៃសម្រាប់សុពលភាព។
• មុខងារខាងក្រៅជាមួយអាគុយម៉ង់ពីរ &MyMod.my_fun/2នាងនឹងទទួលបានគូ serie, value សម្រាប់សុពលភាព;
• ការអនុវត្តម៉ូឌុល Vela.Validator;
• ប៉ារ៉ាម៉ែត្រកំណត់រចនាសម្ព័ន្ធ thresholdនិង - ជាជម្រើស - compare_byសូមមើលជំពូក ប្រៀបធៀប ខាងក្រោម។

ប្រសិន​បើ​ការ​ផ្ទៀងផ្ទាត់​បាន​ជោគជ័យ តម្លៃ​ត្រូវ​បាន​បន្ថែម​ទៅ​ក្នុង​បញ្ជី​ក្រោម​គន្លឹះ​ដែល​ត្រូវ​គ្នា បើ​មិន​ដូច្នេះ​ទេ tuple {serie, value} ទៅកាន់ :__errors_.

ប្រៀបធៀប

តម្លៃ​ដែល​រក្សា​ទុក​ក្នុង​ជួរ​ដេក​ទាំង​នេះ​អាច​ជា​អ្វី​ក៏​បាន។ បង្រៀន Vela ដើម្បីប្រៀបធៀបពួកវា វាចាំបាច់ក្នុងការផ្ទេរ compare_by ប៉ារ៉ាម៉ែត្រនៅក្នុងនិយមន័យស៊េរី (លុះត្រាតែតម្លៃមិនអាចប្រៀបធៀបជាមួយស្តង់ដារ Kernel.</2); ប៉ារ៉ាម៉ែត្រនេះត្រូវតែជាប្រភេទ (Vela.value() -> number()). តាមលំនាំដើមវាសាមញ្ញ & &1.

ដូចគ្នានេះផងដែរ អ្នកអាចឆ្លងប៉ារ៉ាម៉ែត្រទៅការកំណត់ជួរ comparator ដើម្បីគណនាតម្លៃដីសណ្តរ (min/max); ឧទាហរណ៍ដោយការបញ្ជូន Date.diff/2 ក្នុងនាមជាអ្នកប្រៀបធៀប អ្នកអាចទទួលបាន deltas ត្រឹមត្រូវសម្រាប់កាលបរិច្ឆេទ។

មធ្យោបាយងាយស្រួលមួយទៀតដើម្បីធ្វើការគឺឆ្លងកាត់ប៉ារ៉ាម៉ែត្រ thresholdដែលកំណត់សមាមាត្រអនុញ្ញាតអតិបរមានៃតម្លៃថ្មីទៅ {min, max} ចន្លោះពេល។ ដោយសារវាត្រូវបានបញ្ជាក់ជាភាគរយ មូលប្បទានប័ត្រមិនប្រើទេ។ comparatorប៉ុន្តែនៅតែប្រើ compare_by. ឧទាហរណ៍ ដើម្បីបញ្ជាក់តម្លៃកម្រិតសម្រាប់កាលបរិច្ឆេទ អ្នកត្រូវតែបញ្ជាក់ compare_by: &DateTime.to_unix/1 (ដើម្បីទទួលបានតម្លៃចំនួនគត់) និង threshold: 1បណ្តាលឱ្យតម្លៃថ្មីត្រូវបានអនុញ្ញាតលុះត្រាតែពួកគេចូល ±band ចន្លោះពេលពីតម្លៃបច្ចុប្បន្ន។

ទីបំផុតអ្នកអាចប្រើបាន។ Vela.equal?/2 ដើម្បីប្រៀបធៀបឃ្លាំងសម្ងាត់ពីរ។ ប្រសិនបើតម្លៃកំណត់មុខងារមួយ។ equal?/2 ឬ compare/2បន្ទាប់មកមុខងារទាំងនេះនឹងត្រូវបានប្រើសម្រាប់ការប្រៀបធៀប បើមិនដូច្នេះទេយើងប្រើដោយឆោតល្ងង់ ==/2.

ការទទួលបានតម្លៃ

ដំណើរការស្ថានភាពបច្ចុប្បន្នជាធម្មតាចាប់ផ្តើមដោយការហៅទូរសព្ទ Vela.purge/1ដែលដកតម្លៃដែលលែងប្រើ (ប្រសិនបើ validator ចងទៅ timestamps) បន្ទាប់មកអ្នកអាចហៅបាន។ Vela.slice/1ដែលនឹងត្រឡប់មកវិញ keyword ជាមួយឈ្មោះជួរដេកជាគ្រាប់ចុច និងទីមួយ តម្លៃពិតប្រាកដ។

អ្នកក៏អាចប្រើផងដែរ។ get_in/2/pop_in/2 សម្រាប់ការចូលប្រើកម្រិតទាបចំពោះតម្លៃក្នុងជួរនីមួយៗ។

កម្មវិធី

Vela អាចមានប្រយោជន៍ខ្លាំងណាស់ជាឃ្លាំងសម្ងាត់ស៊េរីពេលវេលានៅក្នុងស្ថានភាពដំណើរការដូច GenServer/Agent. យើង​ចង់​មិន​ប្រើ​តម្លៃ​វគ្គ​ដែល​ជាប់​គាំង​ឡើយ ហើយ​ដើម្បី​ធ្វើ​វា​យើង​គ្រាន់តែ​រក្សា​ដំណើរការ​ជាមួយ​នឹង​ដំណើរការ​របស់​រដ្ឋ Velaជាមួយ​នឹង​កម្មវិធី​បញ្ជាក់​ខាងក្រោម។

@impl Vela.Validator
def valid?(_key, %Rate{} = rate),
  do: Rate.age(rate) < @death_age

и Vela.purge/1 ដោយស្ងាត់ស្ងៀមលុបតម្លៃ stale ទាំងអស់រាល់ពេលដែលយើងត្រូវការទិន្នន័យ។ ដើម្បីចូលប្រើតម្លៃជាក់ស្តែងយើងគ្រាន់តែហៅ Vela.slice/1ហើយនៅពេលដែលប្រវត្តិសាស្រ្តតូចមួយនៃវគ្គសិក្សាត្រូវបានទាមទារ (ស៊េរីទាំងមូល) យើងគ្រាន់តែបញ្ជូនវាមកវិញ - តម្រៀបរួចហើយ - ជាមួយនឹងតម្លៃដែលមានសុពលភាព។

• GitHub
• Hexdocs

ឃ្លាំងសម្ងាត់ពេលវេលាដ៏រីករាយ!

ប្រភព: www.habr.com