El lenguaje Gox utiliza el motor de sintaxis Qlang de forma predeterminada. El lenguaje de scripting Qlang se basa en el lenguaje Go (Golang) con ciertas mejoras. Los tipos de datos se heredan básicamente del lenguaje Go, y la asignación de datos y otras operaciones son básicamente similares pero ligeramente mejoradas y modificadas. Una diferencia importante es que el lenguaje Gox usa escritura dinámica, y la diferencia con el lenguaje Go se refleja principalmente en:
- No es necesario declarar el tipo antes de la asignación de variable. Por ejemplo, los siguientes son todos los métodos de asignación de variables legales. Al asignar, el lenguaje Gox determinará automáticamente el tipo; además, puede usar "=" o ": =", y el efecto es el mismo Sí, ": =" no significa declarar variables y asignar valores como en el lenguaje Go. Por lo tanto, generalmente se recomienda usar directamente "=" para asignar variables.
a = 1
b = "abc"
- La misma variable puede asignarse a diferentes tipos uno tras otro, lo que significa que en el lenguaje Gox, el tipo de variable es variable, que obviamente es diferente del lenguaje Go.
a = 1
a = "list"
a = true
Es posible asignar la variable a a un entero, una cadena y un booleano en la secuencia anterior.
Distingue mayúsculas y minúsculas
Tenga en cuenta que el lenguaje Gox también distingue entre mayúsculas y minúsculas, y varios identificadores (incluidos nombres de variables, nombres de funciones, nombres de estructuras, etc.) se consideran diferentes si tienen diferentes mayúsculas.
Declaración y asignación de variables
En el lenguaje Gox no hay declaración de variable local. Es decir, si ya existe una variable global a, entonces la variable con el mismo nombre en el cuerpo de la función o bloque de código incrustado se considera una operación sobre la variable global. Se debe prestar especial atención a este punto. , Las variables globales deben nombrarse con cuidado. Se recomienda aumentar la G al final (es decir, global) para indicar la diferencia:
a = 1
fn() {
a = 2
}()
println(a)
Entre ellos, fn es una palabra clave para definir funciones en el lenguaje Gox, que es equivalente a func en el lenguaje Go o función en otros idiomas. println es una función incorporada del lenguaje Gox, que se utiliza para generar información, que es lo mismo que println en otros idiomas. Después de una función definida, puede agregar paréntesis para llamarla directamente Este es el método de definición y ejecución de una función anónima. Después de ejecutar este código, obtendrá el siguiente resultado:
2
Puede verse que el valor de la variable global a cambió de 1 a 2 después de que se ejecutó la función anónima.
La excepción es que el nombre del parámetro en la definición de la función afectará a esto, el siguiente código,
b = "I'm fine."
fn(b) {
b = "Hi!"
}(b)
println(b)
El resultado de la ejecución es:
I'm fine.
Se puede ver claramente que dado que la función anónima definida en este código requiere un parámetro y el nombre es el mismo que el nombre de la variable global b, en esta función, la operación sobre la variable b se basa en el valor de la variable pasada a la función. Para la operación, sabemos que para el parámetro pasado por valor, operarlo en la función no afectará la variable original en sí, por lo que el valor de la salida de la variable global b después de que se ejecuta la función permanece sin cambios.
Además, tenga en cuenta que para el método de llamada de una función anónima con parámetros, los parámetros requeridos deben incluirse entre los siguientes paréntesis, y la b en la definición de función de fn y la b ingresada en la función que llama representan dos conceptos, el primero Es el parámetro formal de la función, el segundo se refiere a la variable global b, no la confunda.
Tipo booleano
El tipo booleano generalmente se llama booleano en inglés, también conocido como bool. El valor de los datos de tipo booleano es solo verdadero y falso, que representan los conceptos opuestos de verdadero y falso, sí o no, respectivamente. Los valores o variables booleanos se utilizan a menudo en el código de rama de juicio condicional.
b = true
printf("[%T] %v\n", b, b)
c = false
printf("[%T] %v\n", c, c)
printf("!b = %v\n", !b)
printf("b == c: %v\n", b == c)
printf("1 > 14: %v\n", 1 > 14)
printf("b == true: %v\n", b == true)
printf("b && c: %v\n", b && c)
printf("b || c: %v\n", b || c)
En el código anterior, la función printf también es una función incorporada del lenguaje Gox, que es básicamente la misma que la función printf de otros lenguajes, y es exactamente la misma que la función printf en el lenguaje Go. Por lo tanto, si desea generar un retorno de carro y un avance de línea, también debe usar el carácter de escape "\ n".
Después de ejecutar este código, el resultado es el siguiente:
λ gox -gopath test
[bool] true
[bool] false
!b = false
b == c: false
1 > 14: false
b == true: true
b && c: false
b || c: true
Entre ellos, se puede ver que el valor de la variable a es verdadero, el valor de la variable b es falso, "!" Es el operador de negación (también llamado "no"), si es falso, la negación es verdadera y la negación de verdadero es falso. El resultado del cálculo de muchas expresiones también es de tipo bool, como "bc "significa juzgar si los valores de la variable byc son iguales ("El símbolo indica si los valores de la variable en ambos lados son iguales), y el resultado también es un valor de tipo bool. Dado que los valores en byc no son iguales, el resultado del cálculo de "b == c" es falso. Por lo tanto, b = El resultado de la expresión = verdadero es verdadero, porque el valor de b es verdadero. "&&" y "||" significan "Y lógico" y "O lógico", lo cual es consistente con muchos otros lenguajes. Verdadero && verdadero sigue siendo verdadero, verdadero && falso es falso, falso && verdadero o falso, falso && falso también es falso; y verdadero || verdadero es verdadero, verdadero || falso o falso, falso || verdadero también es verdadero, falso || falso es falso.
Tipo entero
c1 = 19
c2 = 18
println(c1 + c2/3)
printfln("%T, %v", c1, c1)
printfln("%T", c1+c2)
printfln("%T", c2/3)
printfln("%T", c1+c2/3)
printfln("%T, %v", (c1+c2/3)*6, (c1+c2/3)*6)
c1++
c1 *= 3
c2 += 5
c2--
printfln("c1: %v, c2: %v, %T", c1, c2, c1)
El resultado de la ejecución de este código es:
λ gox -gopath test
25
int, 19
int
int
int
int, 150
c1: 60, c2: 22, int
Puede verse claramente que el resultado de las operaciones con enteros es generalmente un certificado. Y los enteros son todos de 64 bits. Además, los operadores ++, -, * =, + = también son válidos (y - = y / = también se pueden usar).
Además, printfln es una función incorporada del lenguaje Gox, que es equivalente a la función printf y generará un retorno de carro adicional al final. Y "% T" y "% v" son caracteres de formato heredados del lenguaje Go, "% T" representa el tipo de la variable correspondiente después de la salida y "% v" es la representación de cadena de la salida de cualquier variable.
El lenguaje Gox también admite int64, uint8, rune y otros tipos comunes en el lenguaje Go, que se utilizarán en algunas llamadas a funciones y se pueden convertir de las siguientes formas cuando sea necesario:
c1 = 19
c2 = int64(c1)
Tipo de punto flotante
f1 = 1.32
previus_f1 = f1
f1 = f1 * 0.8
print(previus_f1, "*", 0.8, "=", f1)
println()
f2 = 0.99
f2 /= 0.3
print(0.99, "/", 0.3, "=", f2, "\n")
El resultado de la ejecución es:
λ gox -gopath test
1.32*0.8=1.056
0.99/0.3=3.3000000000000003
Cabe señalar que la impresión también es una función incorporada del lenguaje Gox. La función es similar a la de imprimir en otros idiomas. Si desea generar caracteres de retorno de carro y salto de línea, puede usar los dos métodos que se muestran en este código, uno es agregar uno sin parámetros La función println, la otra es generar un carácter de escape más "\ n".
Tipo de cadena
A continuación, se muestran algunos ejemplos de asignación y operación de cadenas:
s1 = "abc"
s2 = s1 + "3"
pv("s2")
println(s1, "+", "3", "=", s2)
s5 = "上善若水"
pv("s5")
s6 = []byte(s5)
println(s6)
t = rune(5)
pv("t")
s7 = []rune("上善若水")
pv("s7")
pl("s5[1:2] = %#v", s5[1:2])
pl("s6[1:2] = %#v", s6[1:2])
pl("s7[1:2] = %#v", s7[1:2])
pl("string(s7[1:3]) = %#v", string(s7[1:3]))
pl("string([]byte(string(s7[1:3]))) = %#v", string([]byte(string(s7[1:3]))))
pl("%c", s5[1])
pl("%c", s6[1])
pl("%c", s7[1])
pl("%T, %#v", s5[1], s5[1])
pl("%T, %#v", s6[1], s6[1])
pl("%T, %#v", s7[1], s7[1])
for i = 0; i < len(s5); i++ {
pl("%v: %v", i, s5[i])
}
for v = range s7 {
pl("%#T, %v", byte(v), byte(v))
}
El resultado de la operación es:
λ gox -gopath test
s2(string): abc3
abc + 3 = abc3
s5(string): 上善若水
[228 184 138 229 150 132 232 139 165 230 176 180]
t(int32): 5
s7([]int32): [19978 21892 33509 27700]
s5[1:2] = "\xb8"
s6[1:2] = []byte{0xb8}
s7[1:2] = []int32{21892}
string(s7[1:3]) = "善若"
string([]byte(string(s7[1:3]))) = "善若"
¸
¸
善
int, 184
int, 184
int, 21892
0: 228
1: 184
2: 138
3: 229
4: 150
5: 132
6: 232
7: 139
8: 165
9: 230
10: 176
11: 180
int, 0
int, 1
int, 2
int, 3
Las cosas a tener en cuenta aquí son:
- La función pv puede ver el nombre, tipo y valor de la variable, lo cual es más conveniente cuando se depura el código, pero tenga en cuenta que el parámetro de la función requiere la entrada del nombre de la variable, que es una cadena, y comillas;
- La función pl es la misma que printfln, solo una abreviatura;
- El significado de la suma de cadenas es concatenar (o fusionar) dos cadenas;
- Al igual que el lenguaje Go, para los caracteres codificados en UTF-8, se pueden procesar correctamente convirtiéndolos al tipo de runa []. Por lo tanto, para atravesar cadenas utf-8 correctamente, debe convertirlas al tipo de runa [] (el tipo de runa es esencialmente tipo int32);
Tipo vacío nulo
Los tipos vacíos en el lenguaje Gox no se utilizan realmente en tantos escenarios. Los usos principales son los siguientes:
- Se utiliza para declarar una variable por adelantado, y el tipo o valor puede no ser determinado durante la declaración; por ejemplo, al definir una variable global asignada posteriormente; pero de hecho, para este propósito, el lenguaje Gox puede declarar directamente una variable con nombre de variable;
- Se utiliza para la interacción y el juicio al llamar a funciones en la biblioteca de idiomas de Go que devuelven nil, como los tipos de error comunes;
Vea el siguiente ejemplo:
pv("aaa")
println(aaa)
aaa = 18
pv("aaa")
println("aaa")
b = nil
pv("b")
println(b)
println("------")
c, errT = tk.StrToInt("12ab")
if errT != nil {
println("Error:", errT.Error())
}
pv("c")
pv("errT")
c, errT = tk.StrToInt("123")
pv("c")
pv("errT")
if errT != nil {
println("Error:", errT.Error())
}
El resultado de la ejecución es:
aaa(spec.undefinedType): undefined
undefined
aaa(int): 18
aaa
b(<nil>): <nil>
<nil>
------
Error: strconv.ParseInt: parsing "12ab": invalid syntax
c(int): 0
errT(*strconv.NumError): strconv.ParseInt: parsing "12ab": invalid syntax
c(int): 123
errT(<nil>): <nil>
La función tk.StrToInt en el código es una función que devuelve el tipo de error.Cuando la cadena pasada en el parámetro no se puede convertir a un tipo entero, el segundo valor (tipo de error) devuelto no será nulo pero se puede convertir normalmente. Devolverá un valor nulo.
También tenga en cuenta que en el lenguaje Gox, si una variable es referenciada directamente (no asignada) sin definir una variable, obtendrá el valor indefinido, que es algo similar al lenguaje Javascript. En el lenguaje Go, tal uso producirá pánico. Por supuesto, también se puede utilizar para juicio condicional.
si un == indefinido {…}
Juzgar. Para matrices y mapas (mapa), undefined también se usa para determinar si hay un valor de índice y un valor clave requeridos, por ejemplo:
m = map[string]string{"a": "1", "b": "ABC"}
v1 = m["a"]
pl("v1: %#v", v1)
v2 = m.a
pl("v2: %#v", v2)
v3 = m["c"]
pl("v3: %#v", v3)
if v3 == undefined {
pln("v3 is undefined")
}
El resultado de la operación es:
λ gox -gopath test
v1: "1"
v2: "1"
v3: 0
v3 is undefined
Puede ver cómo usar undefined y el valor mostrado cuando se imprime.
Conversión de tipo de datos
En el lenguaje Gox, puede usar int (a), string (s), etc. para realizar la conversión de tipos de datos de manera similar al lenguaje Go. Para algunos tipos que no se pueden convertir directamente, debe usar algunas otras funciones para realizar la acción de conversión. Además, puede utilizar el tipo de función incorporado para obtener el tipo de una variable. El siguiente código de ejemplo demuestra estos usos.
a = 1
b = int64(2)
println("type of a is:", type(a))
println("type of b is:", type(b))
println("a + b =", a+b)
printfln("a + b = %#v", a+b)
a1 = tk.IntToStr(a)
b1 = tk.IntToStr(b)
printfln("type of a1 is: %T", a1)
printfln("value of a1 is: %v", a1)
printfln("internal value of a1 is: %#v", a1)
println("a1 + b1 =", a1+b1)
printfln("a1 + b1 = %#v", a1+b1)
a2 = tk.StrToFloat64WithDefaultValue(a1, 0)
b2 = tk.StrToFloat64WithDefaultValue(b1, 0)
printfln("a2 + b2 = %#v", a2+b2)
printfln("type of a2 + b2 is: %T", a2+b2)
El resultado de ejecución es:
λ gox -gopath test
type of a is: int
type of b is: int64
a + b = 3
a + b = 3
type of a1 is: string
value of a1 is: 1
internal value of a1 is: "1"
a1 + b1 = 12
a1 + b1 = "12"
a2 + b2 = 3
type of a2 + b2 is: float64