Módulo de visualización para construir estrategias comerciales - en profundidad

Tipo de módulo lógico
- 1. Módulo condicional
  
  Este módulo se utiliza para el juicio condicional combinado y puede agregar múltiples ramas condicionales.
  Haga clic en el pequeño ícono de "engranaje" para agregar ramas condicionales.
  
  El ejemplo de uso del módulo condicional se combina con el siguiente módulo para realizar pruebas.
- 2. Módulo de comparación numérica
  
  Este módulo se utiliza para comparar dos valores (también se puede considerar que este módulo y el módulo de valor se combinan en un módulo de expresión) y devolver un valor booleano.
  Este módulo puede juzgar si los valores de ambos lados son "mayores que", "menores que", "mayores o iguales que", "menores o iguales que", "no iguales a" o "iguales a". .
  Las posiciones de las espigas (abolladuras) en ambos lados de las opciones del cuadro desplegable se pueden integrar con módulos numéricos y variables (siempre que el módulo devuelva un valor numérico).
  
  Un ejemplo de uso del "Módulo condicional" y el "Módulo de comparación de valores" para combinarlos en un ejemplo de juicio de valor:
  
  Como puedes ver, este ejemplo tiene un total de 3 ramas al juzgar las condiciones.
  
  Al igual que el uso de declaraciones if en las estrategias de JavaScript.
```
            
            
            
function main () {
    var a = 1
    var b = 2
    if (a > b) {
        Log("a > b")
    } else if (a < b) {
        Log("a < b")
    } else {
        Log("a == b")
    }
}
```
- 3. Módulo OR lógico, AND lógico
  
  Este módulo se utiliza para realizar la operación "OR" o la operación "AND". Los módulos que intervienen en la operación (que pueden ser módulos que devuelven valores booleanos o módulos que devuelven valores numéricos) están incrustados en las posiciones de las espigas (tenon) en ambos lados de las opciones del cuadro desplegable en el medio del módulo.
  
  Antes de probar este módulo específicamente, aprendamos primero sobre el módulo que representa el valor booleano "verdadero"/"falso" (establecido usando el cuadro desplegable), el módulo que representa el valor booleano "no" y el módulo que representa el valor vacío.
  - Los módulos vacíos representannull Valor, utilizado para comparar si alguna variable es nula.
  - Los módulos booleanos Verdadero/Falso representantrue / false Valor, utilizado para determinar el valor booleano devuelto por ciertos módulos o combinaciones de módulos.
  - El módulo booleano "no" representa el! , utilizado para realizar una operación NOT booleana.
  Ejemplo de prueba:
  
  Se puede ver que los módulos "OR lógico, AND lógico" también se pueden anidar.
  
  Ejemplo de unión de módulos anidados:
  
  Código de política de JavaScript equivalente:
```
            
            
            
function main () {
    var a = 1 
    var b = 2
    Log((true && !false) || (a==b))
    Log(null)
}
```
  !false no es falso, es decir, es un valor verdadero. Expresión lógica: (true && !false): se opera sobre dos valores verdaderos y el resultado es verdadero.
  a==b obviamente no es igual, por lo tanto es falso.
  Un valor verdadero y un valor falso se combinan lógicamente mediante OR para producir un valor verdadero.
  
  Resultados de la carrera:
- 4. Módulo de operación ternaria
  
  Este módulo también se llama módulo de aserción y su función es similar al operador ternario en algunos lenguajes de programación.
  
  Este módulo también se puede anidar. La esencia del módulo de operaciones ternarias también es la lógica de juicio condicional y su función es similar a la del módulo condicional.
  
  Refactorice el tutorial del módulo condicional anterior utilizando el módulo de operación ternaria.
  El siguiente es un ejemplo:
  
  Aquí está el código de política escrito en JavaScript:
```
            
            
            
function main () {
    var a = 1
    var b = 2
    Log(a < b ? b : (a > b ? a : "相等"))
}
```
  Si está interesado, puede ajustar los valores de a y b y ejecutar un backtest.
Tipo de módulo de matemáticas

En muchos de los ejemplos explicados anteriormente hemos utilizado algunos módulos matemáticos en mayor o menor medida.
A continuación explicaremos algunos módulos de matemáticas que aún no hemos aprendido.
- 1. Módulo de función trigonométrica
  
  Tenga en cuenta que los parámetros completados para la posición de la espiga (tenon) de este módulo son valores de ángulo, no valores de radianes.
- 2. Módulo numérico Pi
  
  Impresión de prueba retrospectiva:
- 3. Módulo de números aleatorios dentro de un rango de valores determinado
  
  Este módulo toma un número aleatorio dentro de un rango numérico establecido. La posición de la espiga (cóncava) del módulo puede completar directamente el valor numérico o utilizar una variable como valor inicial y final del rango aleatorio.
  
  Al igual que el código de estrategia de JavaScript:
```
            
            
            
function main () {
    var a = 1
    var b = 9
    Log(_N(a + Math.random() * (b - a), 0))
}
```
- 4. Módulo de rango de valor límite
  
  Este módulo limitará las variables rellenadas en la primera posición de espiga (tenon) al rango establecido para la segunda y tercera posición de espiga (tenon).
  Si el valor es mayor que el valor máximo del rango, el módulo devuelve el valor máximo del rango. Si el valor es menor que el valor mínimo del rango, el módulo devuelve el valor mínimo.
  Si está dentro de este rango, se devuelve el valor de la propia variable que toma el valor de la posición de la primera espiga (cóncava).
  
  Al igual que el código de estrategia de JavaScript:
```
            
            
            
function main () {
    var a = 9
    Log(Math.min(Math.max(2, a), 5))
}
```
- 5. Módulo de resto
  
  Este módulo realiza operaciones de resto numérico en los módulos numéricos establecidos para las posiciones de espiga (ranura).
  
  64 dividido por 10 es 6 con un resto de 4.
- 6. Módulo de operación de lista
  
  Este módulo opera sobre un módulo de lista (calculando la suma de elementos en una lista, etc.).
  
  Al igual que el código de estrategia de JavaScript:
```
            
            
            
function sum (arr) {
    var ret = 0
    for (var i in arr) {
        ret += arr[i]
    }
    return ret 
}

function main () {
    var b = 2
    var a = 1
    Log(sum([b,a,b,a,a]))
}
```