ਵੇਲਾ → ਸਮਾਂ ਲੜੀ ਅਤੇ ਹੋਰ ਲਈ ਸਮਾਰਟ ਕੈਸ਼

ਫਿਨਟੇਕ ਵਿੱਚ, ਸਾਨੂੰ ਅਕਸਰ ਮੁਦਰਾ ਐਕਸਚੇਂਜ ਰੇਟ ਡੇਟਾ ਦੇ ਕਾਫ਼ੀ ਵੱਡੇ ਵੋਲਯੂਮ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨੀ ਪੈਂਦੀ ਹੈ। ਅਸੀਂ ਵੱਖ-ਵੱਖ ਸਰੋਤਾਂ ਤੋਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਦਾ ਆਪਣਾ ਵਿਚਾਰ ਹੈ ਕਿ ਕੱਲ੍ਹ, ਅਗਲੇ ਦਿਨ, ਅਗਲੇ ਮਹੀਨੇ ਅਤੇ ਇੱਥੋਂ ਤੱਕ ਕਿ ਅਗਲੇ ਤਿੰਨ ਸਾਲਾਂ ਲਈ ਐਕਸਚੇਂਜ ਦਰਾਂ ਨੂੰ ਕਿਵੇਂ ਐਕਸਟਰਾਪੋਲੇਟ ਕਰਨਾ ਹੈ। ਜੇਕਰ ਕੋਈ ਵਿਅਕਤੀ ਦਰਾਂ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰ ਸਕਦਾ ਹੈ ਸੱਜੇ, ਇਹ ਕਾਰੋਬਾਰ ਨੂੰ ਬੰਦ ਕਰਨ ਅਤੇ ਸਿਰਫ਼ ਮੂਰਖਤਾ ਨਾਲ ਪੈਸੇ ਨੂੰ ਅੱਗੇ ਅਤੇ ਪਿੱਛੇ ਬਦਲਣ ਦਾ ਸਮਾਂ ਹੋਵੇਗਾ. ਕੁਝ ਸਰੋਤ ਵਧੇਰੇ ਭਰੋਸੇਮੰਦ ਹੁੰਦੇ ਹਨ, ਕੁਝ ਲਗਭਗ ਸਹੀ ਮੁੱਲਾਂ ਦੇ ਦੁਰਲੱਭ ਸੰਮਿਲਨਾਂ ਦੇ ਨਾਲ ਪੂਰਾ ਕੂੜਾ ਸਪਲਾਈ ਕਰਦੇ ਹਨ, ਪਰ ਵਿਦੇਸ਼ੀ ਜੋੜਿਆਂ ਲਈ। ਸਾਡਾ ਕੰਮ ਪ੍ਰਤੀ ਸਕਿੰਟ ਇਹਨਾਂ ਹਜ਼ਾਰਾਂ ਮੁੱਲਾਂ ਨੂੰ ਖੋਜਣਾ ਅਤੇ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨਾ ਹੈ ਕਿ ਗਾਹਕਾਂ ਨੂੰ ਅਸਲ ਵਿੱਚ ਕੀ ਦਿਖਾਉਣਾ ਹੈ। ਸਾਨੂੰ ਟਨਾਂ ਗੰਦਗੀ ਅਤੇ ਗਾਦ ਤੋਂ ਇੱਕ ਸਹੀ ਮੁੱਲ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਜਿਵੇਂ ਫਲੇਮਿੰਗੋ ਦੁਪਹਿਰ ਦੇ ਖਾਣੇ ਵਿੱਚ ਕਰਦੇ ਹਨ।

ਫਲੇਮਿੰਗੋ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਵਿਸ਼ੇਸ਼ਤਾ ਉਹਨਾਂ ਦੀ ਵਿਸ਼ਾਲ ਹੇਠਾਂ ਵੱਲ ਵਕਰ ਕੀਤੀ ਚੁੰਝ ਹੈ, ਜਿਸ ਨਾਲ ਉਹ ਪਾਣੀ ਜਾਂ ਚਿੱਕੜ ਵਿੱਚੋਂ ਭੋਜਨ ਨੂੰ ਫਿਲਟਰ ਕਰਦੇ ਹਨ।
 - ਵਿਕੀ

ਇਸ ਤਰ੍ਹਾਂ ਲਾਇਬ੍ਰੇਰੀ ਦਾ ਜਨਮ ਹੋਇਆ 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, ਅਧਿਆਇ ਦੇਖੋ ਤੁਲਨਾ ਹੇਠਾਂ.

ਜੇਕਰ ਪ੍ਰਮਾਣਿਕਤਾ ਸਫਲ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਮੁੱਲ ਅਨੁਸਾਰੀ ਕੁੰਜੀ ਦੇ ਅਧੀਨ ਸੂਚੀ ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ; ਨਹੀਂ ਤਾਂ, ਟੂਪਲ {serie, value} ਨੂੰ ਜਾਂਦਾ ਹੈ :__errors_.

ਤੁਲਨਾ

ਇਹਨਾਂ ਕਤਾਰਾਂ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਮੁੱਲ ਕੁਝ ਵੀ ਹੋ ਸਕਦੇ ਹਨ। ਸਿਖਾਉਣਾ Vela ਉਹਨਾਂ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ, ਟ੍ਰਾਂਸਫਰ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ compare_by ਲੜੀ ਪਰਿਭਾਸ਼ਾ ਵਿੱਚ ਪੈਰਾਮੀਟਰ (ਜਦੋਂ ਤੱਕ ਮੁੱਲਾਂ ਦੀ ਤੁਲਨਾ ਮਿਆਰੀ ਨਾਲ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕਦੀ Kernel.</2); ਇਹ ਪੈਰਾਮੀਟਰ ਕਿਸਮ ਦਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ (Vela.value() -> number()). ਮੂਲ ਰੂਪ ਵਿੱਚ ਇਹ ਸਧਾਰਨ ਹੈ & &1.

ਨਾਲ ਹੀ, ਤੁਸੀਂ ਕਤਾਰ ਪਰਿਭਾਸ਼ਾ ਲਈ ਇੱਕ ਪੈਰਾਮੀਟਰ ਪਾਸ ਕਰ ਸਕਦੇ ਹੋ comparator ਡੈਲਟਾ ਮੁੱਲਾਂ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ (min/max); ਉਦਾਹਰਨ ਲਈ, ਸੰਚਾਰ ਦੁਆਰਾ Date.diff/2 ਤੁਲਨਾਕਾਰ ਵਜੋਂ, ਤੁਸੀਂ ਤਾਰੀਖਾਂ ਲਈ ਸਹੀ ਡੈਲਟਾ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ।

ਕੰਮ ਕਰਨ ਦਾ ਇੱਕ ਹੋਰ ਸੁਵਿਧਾਜਨਕ ਤਰੀਕਾ ਪੈਰਾਮੀਟਰ ਪਾਸ ਕਰਨਾ ਹੈ 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 ਹਰ ਵਾਰ ਜਦੋਂ ਸਾਨੂੰ ਡੇਟਾ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਤਾਂ ਚੁੱਪਚਾਪ ਸਾਰੇ ਪੁਰਾਣੇ ਮੁੱਲਾਂ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ। ਅਸਲ ਮੁੱਲਾਂ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਅਸੀਂ ਬਸ ਕਾਲ ਕਰਦੇ ਹਾਂ Vela.slice/1, ਅਤੇ ਜਦੋਂ ਕੋਰਸ ਦਾ ਇੱਕ ਛੋਟਾ ਇਤਿਹਾਸ (ਪੂਰੀ ਲੜੀ) ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸਨੂੰ ਵਾਪਸ ਕਰ ਦਿੰਦੇ ਹਾਂ - ਪਹਿਲਾਂ ਹੀ ਕ੍ਰਮਬੱਧ - ਪ੍ਰਮਾਣਿਤ ਮੁੱਲਾਂ ਦੇ ਨਾਲ।

• GitHub
• ਹੈਕਸਡੌਕਸ

ਹੈਪੀ ਟਾਈਮ ਸੀਰੀਜ਼ ਕੈਚਿੰਗ!

ਸਰੋਤ: www.habr.com