En el idioma Gox, el tipo de mapa se utiliza para representar el concepto de "diccionario" en el idioma general, que también es coherente con el idioma Go. Para la declaración de mapas, la asignación y otras operaciones, echemos un vistazo al siguiente ejemplo. Dado que el lenguaje Gox usa el motor de sintaxis Qlang de forma predeterminada, aquí hay un ejemplo basado en la sintaxis Qlang, que es el caso si no se menciona específicamente más adelante.
En primer lugar, para la definición y las operaciones básicas del mapa general, echemos un vistazo a la documentación de Qlang en sí, citada aquí ,
a = {"a": 1, "b": 2, "c": 3} // Obtiene un objeto de tipo map [string] int
b = {"a": 1, "b", 2.3, "c" : 3} // Obtener un objeto de tipo map [string] float64
c = {1: “a”, 2: “b”, 3: “c”} // Obtener un objeto de tipo map [int] string
d = {" a ":" hola "," b ": 2.0," c ": verdadero} // obtener un objeto de tipo mapa [cadena] interfaz {}
e = make (mapa [cadena] int) // crear un mapa vacío [ string] int type object
f = make (map [string] map [string] int) // crea un objeto de tipo map [string] map [string] int
g = map [string] int16 {"a": 1, "B": 2} // Crea un objeto de tipo map [string] int16
Similar al idioma Go, el mapa tiene las siguientes operaciones integradas:
n = len (a) // Toma el número de elementos de a
x = a ["b"] // Toma el elemento con la clave "b" en un mapa
x = ab // El mismo significado que el anterior, pero si el elemento "b" no es La existencia entrará en pánico
a ["e"], a ["f"], a ["g"] = 4, 5, 6 // igual que Go language
ae, af, ag = 4, 5, 6 // mismo significado que a ["E"], a ["f"], a ["g"] = 4, 5, 6
delete (a, "e") // elimina el elemento "e" en un mapa
Cabe señalar que el comportamiento de a ["b"] es ligeramente diferente al de Go. En el lenguaje Go, el paradigma común es:
x: = map [string] int {"a": 1, "b": 2}
a, ok: = x ["a"] // Resultado: a = 1, ok = true
if ok {// juzgar a La lógica de la existencia
...
}
c, ok2: = x [“c”] // Resultado: c = 0, ok2 = falso
d: = x [“d”] // Resultado: d = 0
En qlang, se ve así:
x = {"a": 1, "b": 2}
a = x ["a"] // Resultado: a = 1
if a! = undefined {// La lógica para determinar la existencia de un
...
}
c = x [" c "] // Resultado: c = indefinido, tenga en cuenta que no es 0 o nil
d = x [" d "] // Resultado: d = indefinido, tenga en cuenta que no es 0 o nil
Además, al igual que en el idioma Go, cuando se recorren los datos en el mapa, el orden no es seguro, esto debe tenerse en cuenta.
Aquí hay un ejemplo de más operaciones,
// 默认的映射是map[string]interface{}类型的，相当于Gox中的map[string]var
a = {}
pv("a")
// 如果要键值非string，可以指定var或者其他的类型
a = map[var]var{}
pv("a")
// var类型支持各种值
a["Num"] = 3
a[5] = "abc"
a[-1] = true
a["ary"] = [1, "xyz", false]
a[false] = "not true"
a.Item1 = "item 1"
pv("a")
// 内置函数len用于取映射长度，即其中的键值对数
pl("length of a: %v", len(a))
// 可以用“.key”的方式来取map中对应的键值
pl("a.Num: %v", a.Num)
// 键值项可以直接进行计算和其他操作
a["Num"]++
println(a["Num"])
a[5]=a[5]+a[5]
a[5] = a[5][1:]
println(a[5])
// 直接定义以int类型作为键类型
c = map[int]string{}
c[3] = "3"
c[18] = "abc"
c[-198] = "true"
pv("c")
// 此时v是有值的
v = c[18]
if v == undefined {
println("v:", v)
}
// 删除掉该项
delete(c, 18)
println("c:", c)
// 这样索引取键值会报错
// ok = c["b"] // will cause runtime error, since key should be int
// println(ok)
println("---")
// 遍历map的方法
for k, v = range a {
println("[", k, "]:", v)
}
El resultado de la ejecución es:
a(map[string]interface {}): map[]
a(map[interface {}]interface {}): map[]
a(map[interface {}]interface {}): map[false:not true -1:true 5:abc Item1:item 1 Num:3 ary:[1 xyz false]]
length of a: 6
a.Num: 3
4
bcabc
c(map[int]string): map[-198:true 3:3 18:abc]
c: map[-198:true 3:3]
---
[ -1 ]: true
[ ary ]: [1 xyz false]
[ false ]: not true
[ Item1 ]: item 1
[ Num ]: 4
[ 5 ]: bcabc
El código es fácil de entender y contiene comentarios detallados.
- En el lenguaje Gox, puede usar llaves para declarar y construir directamente un mapa. En este momento, corresponde al tipo de interfaz del mapa [cadena] {} en el idioma Go de forma predeterminada. En el lenguaje Gox, el tipo de interfaz {} está representado por var, por lo que , También puede utilizar var como "b = map [var] var {}". El efecto de los dos métodos es el mismo;
- Puede usar el método "c = map [int] var {}" para especificar el tipo de clave. En este caso, si luego usa "c [" a "]" para referirse al elemento de datos en c con una cadena como clave, Hará que el programa ejecute un error;
- En el mapa definido por map [var] var {}, el índice puede ser cualquier tipo de datos, por lo que el código comienza a indexar la variable a con un número (incluso un número negativo), cadena o variable booleana, a la que se puede acceder normalmente. Elementos de datos;
- Si el valor declarado como var en el mapa también puede ser de cualquier tipo, incluso puede ser una matriz u otro mapa
- Utilice la función de eliminación incorporada para eliminar un elemento de datos en el mapa;
- Puede usar "v = c [18]" para obtener el elemento numérico y luego determinar si el valor no está definido para confirmar si hay un elemento numérico con índice 18 en c;
- Puede utilizar un bucle for para recorrer el mapa;
- Recuerde que el mapa también se puede definir directamente como "a = {" a ": 3," b ":" abc "}".