Comparación de lenguajes de programación (arreglo asociativo)

Esta comparación de lenguajes de programación (matrices asociativas) compara las características de las estructuras de datos de matrices asociativas o el procesamiento de búsqueda de matrices para más de 40 lenguajes de programación informática .

La siguiente es una comparación de matrices asociativas (también "mapeo", "hash" y "diccionario") en varios lenguajes de programación.

AWK tiene soporte integrado a nivel de lenguaje para matrices asociativas.

Por ejemplo:

directorio telefónico [ "Sally Smart" ]  =  "555-9999" directorio telefónico [ "John Doe" ]  =  "555-1212" directorio telefónico [ "J. Random Hacker" ]  =  "555-1337"

El siguiente código recorre una matriz asociada e imprime su contenido:

para  ( nombre  en  la agenda telefónica )  { imprimir  nombre ,  " " ,  agenda telefónica [ nombre ] }

El usuario puede buscar elementos en una matriz asociativa y eliminar elementos de la matriz.

A continuación se muestra cómo se pueden simular matrices asociativas multidimensionales en AWK estándar utilizando la concatenación y la variable separadora de cadenas incorporada SUBSEP:

{  # para cada línea de entrada multi [ $ 1  SUBSEP  $ 2 ] ++ ; } # FIN  { for  ( x  in  multi )  { split ( x ,  arr ,  SUBSEP ); print  arr [ 1 ],  arr [ 2 ],  multi [ x ]; } }

No existe una implementación estándar de matrices asociativas en C , pero está disponible una biblioteca de terceros, C Hash Table, con licencia BSD. ^[1]

Otra biblioteca de terceros, uthash, también crea matrices asociativas a partir de estructuras C. Una estructura representa un valor y uno de los campos de la estructura sirve como clave. ^[2]

Por último, la biblioteca GLib también admite matrices asociativas, junto con muchos otros tipos de datos avanzados y es la implementación recomendada del Proyecto GNU. ^[3]

De manera similar a GLib , el marco multiplataforma Core Foundation de Apple ofrece varios tipos de datos básicos. En particular, existen CFDictionary y CFMutableDictionary con recuento de referencias.

C# utiliza las clases de colección proporcionadas por .NET Framework . El tipo de matriz asociativa más utilizado es System.Collections.Generic.Dictionary<TKey, TValue>, que se implementa como una tabla hash mutable. El System.Collections.Immutablepaquete relativamente nuevo, disponible en las versiones 4.5 y posteriores de .NET Framework y en todas las versiones de .NET Core , también incluye el System.Collections.Immutable.Dictionary<TKey, TValue>tipo , que se implementa mediante un árbol AVL . Los métodos que normalmente mutarían el objeto en el lugar devuelven en cambio un nuevo objeto que representa el estado del objeto original después de la mutación.

A continuación se muestran tres formas de completar un diccionario mutable:

• el Addmétodo que agrega una clave y un valor y lanza una excepción si la clave ya existe en el diccionario;
• asignar al indexador, que sobrescribe cualquier valor existente, si está presente; y
• asignando a la propiedad de respaldo del indexador, para el cual el indexador es azúcar sintáctico (no aplicable a C#, consulte los ejemplos de F# o VB.NET).

var dictionary = new Dictionary < string , string > (); dictionary . Add ( "Sally Smart" , "555-9999" ); dictionary [ "John Doe" ] = "555-1212" ; // No permitido en C#. // dictionary.Item("J. Random Hacker") = "553-1337"; dictionary [ "J. Random Hacker" ] = "553-1337" ;          

El diccionario también se puede inicializar durante la construcción utilizando un "inicializador de colección", que compila llamadas repetidas a Add.

var diccionario = nuevo Diccionario < cadena , cadena > { { "Sally Smart" , "555-9999" }, { "John Doe" , "555-1212" }, { "J. Random Hacker" , "553-1337" } };                  

Los valores se recuperan principalmente utilizando el indexador (que genera una excepción si la clave no existe) y el TryGetValuemétodo, que tiene un parámetro de salida para el valor buscado y un valor de retorno booleano que indica si se encontró la clave.

var sallyNumber = diccionario [ "Sally Smart" ];   

var sallyNumber = ( diccionario.TryGetValue ( " Sally Smart" , salida var resultado ) ? resultado : "n/a " ;          

En este ejemplo, el sallyNumbervalor ahora contendrá la cadena "555-9999".

Un diccionario puede verse como una secuencia de claves, una secuencia de valores o una secuencia de pares de claves y valores representados por instancias del KeyValuePair<TKey, TValue>tipo, aunque no hay garantía de orden. Para un diccionario ordenado, el programador podría optar por utilizar un SortedDictionary<TKey, TValue>o utilizar el método de extensión .Sort LINQ al enumerar.

A continuación se muestra la enumeración utilizando un bucle foreach :

// recorrer la colección y mostrar cada entrada. foreach ( KeyValuePair < ​​string , string > kvp in dictionary ) { Console.WriteLine ( " El número de teléfono de {0} es {1}" , kvp.Key , kvp.Value ) ; }       

C++ tiene una forma de matriz asociativa llamada std::map(consulte la Biblioteca de plantillas estándar#Contenedores ). Se podría crear un mapa de la guía telefónica con el siguiente código en C++:

#include <mapa> #include <cadena> #include <utilidad> int main () { std :: map < std :: string , std :: string > libreta_telefonica ; libreta_telefonica.insert ( std :: make_pair ( "Sally Smart" , "555-9999" )); libreta_telefonica.insert ( std :: make_pair ( " John Doe" , "555-1212" )); libreta_telefonica.insert ( std :: make_pair ( " J. Random Hacker" , " 553-1337 " ) ); }           

O de manera menos eficiente, ya que esto crea std::stringvalores temporales:

#include <mapa> #include <cadena> int main () { std :: map < std :: string , std :: string > libreta_telefonica ; libreta_telefonica [ "Sally Smart" ] = "555-9999" ; libreta_telefonica [ "John Doe" ] = "555-1212" ; libreta_telefonica [ "J. Random Hacker" ] = "553-1337" ; }             

Con la extensión de las listas de inicialización en C++11, se pueden agregar entradas durante la construcción de un mapa como se muestra a continuación:

#include <mapa> #include <cadena>  int main () { std :: map < std :: string , std :: string > libreta_telefonica { { "Sally Smart" , "555-9999" }, { "John Doe" , "555-1212" }, { "J. Hacker aleatorio" , "553-1337" } }; }        

Puede iterar a través de la lista con el siguiente código (C++03):

std :: map < std :: string , std :: string > :: iterador curr , fin ; para ( curr = phone_book.begin ( ) , fin = phone_book.end (); curr ! = fin ; ++ curr ) std :: cout << curr - > primero << " = " << curr -> segundo << std :: endl ;                    

La misma tarea en C++11:

para ( const auto & curr : libreta_telefonica ) std :: cout << curr .first << " = " << curr .second << std :: endl ;             

Usando el enlace estructurado disponible en C++17 :

para ( const auto & [ nombre , número ] : agenda_telefonica ) { std :: cout << nombre << " = " << número << std :: endl ; }                

En C++, la std::mapclase se basa en plantillas, lo que permite que los tipos de datos de las claves y los valores sean diferentes para las distintas mapinstancias. Para una instancia determinada de la mapclase, las claves deben ser del mismo tipo base. Lo mismo debe ser cierto para todos los valores. Aunque std::mapnormalmente se implementa utilizando un árbol binario de búsqueda autoequilibrado , C++11 define un segundo mapa llamado std::unordered_map, que tiene las características algorítmicas de una tabla hash. Esta es también una extensión de proveedor común para la Biblioteca de plantillas estándarhash_map (STL), normalmente llamada , disponible en implementaciones como SGI y STLPort.

Inicializando un diccionario vacío y agregando elementos en Cobra :

dic  como  Diccionario < de  Cadena ,  Cadena >  =  Diccionario < de  Cadena ,  Cadena > () dic.add ( 'Sally Smart' , ' 555-9999' ) dic.add ( ' John Doe' , ' 555-1212' ) dic.add ( ' J. Random Hacker' , '553-1337 ' )    afirmar  dic [ 'Sally Smart' ]  ==  '555-9999'

Alternativamente, un diccionario se puede inicializar con todos los elementos durante la construcción:

dic  =  {  'Sally Smart' : '555-9999' ,  'John Doe' : '555-1212' ,  'J. Hacker aleatorio' : '553-1337'  }

El diccionario se puede enumerar mediante un bucle for, pero no hay un orden garantizado:

para  clave ,  val  en  dic  imprime  "el número de teléfono de [clave] es [val]"

Una estructura en ColdFusion Markup Language (CFML) es equivalente a una matriz asociativa:

dynamicKeyName  =  "John Doe" ; phoneBook  =  { "Sally Smart"  =  "555-9999" , " #dynamicKeyName# "  =  "555-4321" , "J. Random Hacker"  =  "555-1337" , UnknownComic  =  "???" }; writeOutput ( phoneBook.UnknownComic );  // ??? writeDump ( phoneBook );  // estructura completa

D ofrece soporte directo para matrices asociativas en el lenguaje principal; dichas matrices se implementan como una tabla hash encadenada con árboles binarios. ^[4] El ejemplo equivalente sería:

int main () { string [ string ] libreta_telefonica ; libreta_telefonica [ "Sally Smart" ] = "555-9999" ; libreta_telefonica [ "John Doe" ] = "555-1212" ; libreta_telefonica [ "J. Random Hacker" ] = "553-1337" ; devolver 0 ; }            

Las claves y los valores pueden ser de cualquier tipo, pero todas las claves de una matriz asociativa deben ser del mismo tipo y lo mismo se aplica a los valores dependientes.

Recorrer todas las propiedades y valores asociados e imprimirlos se puede codificar de la siguiente manera:

foreach ( clave , valor ; libreta telefónica ) { writeln ( "Número para " ~ clave ~ ": " ~ valor ); }            

Una propiedad se puede eliminar de la siguiente manera:

libreta_telefonica .remove ( "Sally Smart" ) ;

Delphi admite varios contenedores estándar, incluido TDictionary<T>:

utiliza SysUtils , Generics , Colecciones ;  var PhoneBook : TDictionary < cadena , cadena >; Entrada : TPair < ​​cadena , cadena >;      comenzar PhoneBook := TDictionary < string , string >. Crear ; PhoneBook . Añadir ( 'Sally Smart' , '555-9999' ) ; PhoneBook . Añadir ( 'John Doe' , '555-1212' ) ; PhoneBook . Añadir ( 'J. Random Hacker' , '553-1337' ) ;           para la entrada en la libreta telefónica, haga Writeln ( Formato ( 'Número para %s: %s' , [ Entrada . Clave , Entrada . Valor ])) ; fin .      

Las versiones de Delphi anteriores a 2009 no admiten matrices asociativas directamente. Dichas matrices se pueden simular utilizando la clase TStrings:

procedimiento TForm1 . Button1Click ( Sender : TObject ) ; var DataField : TStrings ; i : Integer ; begin DataField := TStringList . Create ;          Campo de datos . Valores [ 'Sally Smart' ] := '555-9999' ; Campo de datos . Valores [ 'John Doe' ] := '555-1212' ; Campo de datos . Valores [ 'J. Random Hacker' ] := '553-1337' ;         // acceder a una entrada y mostrarla en un cuadro de mensaje ShowMessage ( DataField . Values ​​[ 'Sally Smart' ]) ;  // recorrer la matriz asociativa para i := 0 hasta DataField . Count - 1 do begin ShowMessage ( 'Número para ' + DataField . Names [ i ] + ': ' + DataField . ValueFromIndex [ i ]) ; end ;                   Campo de datos . Libre ; fin ;

Erlang ofrece muchas formas de representar asignaciones; tres de las más comunes en la biblioteca estándar son listas de claves, diccionarios y mapas.

Las listas de claves son listas de tuplas , donde el primer elemento de cada tupla es una clave y el segundo es un valor. En el listsmódulo se proporcionan funciones para operar con listas de claves.

Libreta telefónica = [{ "Sally Smith" , "555-9999" }, { "John Doe" , "555-1212" }, { "J. Random Hacker" , "553-1337" }].       

El acceso a un elemento de la lista de claves se puede realizar con la lists:keyfind/3función:

{_, Teléfono } = listas : keyfind ( "Sally Smith" , 1 , Libreta telefónica ), io : formato ( "Número de teléfono: ~s~n " , [ Teléfono ]).      

Los diccionarios se implementan en el dictmódulo de la biblioteca estándar. Se crea un nuevo diccionario mediante la dict:new/0función y se almacenan nuevos pares clave/valor mediante la dict:store/3función:

PhoneBook1 = dict : new (), PhoneBook2 = dict : store ( "Sally Smith" , "555-9999" , Dict1 ), PhoneBook3 = dict : store ( "John Doe" , "555-1212" , Dict2 ), PhoneBook = dict : store ( "J. Random Hacker" , "553-1337" , Dict3 ).              

Una inicialización en serie de este tipo se representaría de forma más idiomática en Erlang con la función adecuada:

Libreta telefónica = dict : from_list ([{ "Sally Smith" , "555-9999" }, { "John Doe" , "555-1212" }, { "J. Random Hacker" , "553-1337" }]).       

Se puede acceder al diccionario mediante la dict:find/2función:

{ ok , Teléfono } = dict : find ( "Sally Smith" , Libreta telefónica ), io : format ( "Teléfono: ~s~n " , [ Teléfono ]).     

En ambos casos, se puede utilizar cualquier término de Erlang como clave. Las variaciones incluyen el orddictmódulo, que implementa diccionarios ordenados, y el módulo gb_trees, que implementa árboles balanceados generales.

Los mapas se introdujeron en OTP 17.0, ^[5] y combinan las ventajas de las listas de claves y los diccionarios. Un mapa se define utilizando la sintaxis #{ K1 => V1, ... Kn => Vn }:

Libreta telefónica = #{ "Sally Smith" => "555-9999" , "John Doe" => "555-1212" , "J. Random Hacker" => "553-1337" }.          

El módulo dispone de funciones básicas para interactuar con los mapas maps. Por ejemplo, la maps:find/2función devuelve el valor asociado a una clave:

{ ok , Teléfono } = mapas : find ( "Sally Smith" , Libreta telefónica ), io : format ( "Teléfono: ~s~n " , [ Teléfono ]).     

A diferencia de los diccionarios, los mapas pueden coincidir con patrones según:

#{ "Sally Smith" , Teléfono } = Libreta telefónica , io : formato ( "Teléfono: ~s~n " , [ Teléfono ]).    

Erlang también proporciona sintaxis para actualizaciones funcionales: crea un nuevo mapa basado en uno existente, pero con valores modificados o claves adicionales:

PhoneBook2 = PhoneBook #{ % el operador `:=` actualiza el valor asociado con una clave existente "J. Random Hacker" : = "355-7331" ,       % el operador `=>` agrega un nuevo par clave-valor, potencialmente reemplazando uno existente "Alice Wonderland" => "555-1865" }   

En tiempo de ejecución, F# proporciona el Collections.Map<'Key,'Value>tipo, que es un árbol AVL inmutable .

El siguiente ejemplo llama al Mapconstructor, que opera sobre una lista (una secuencia de elementos delimitada por punto y coma encerrada entre corchetes) de tuplas (que en F# son secuencias de elementos delimitadas por comas).

deje que los números = [ "Sally Smart" , "555-9999" ; "John Doe" , "555-1212" ; "J. Random Hacker" , "555-1337" ] |> Mapa             

Los valores se pueden buscar a través de uno de los Mapmiembros, como su indexador o Itempropiedad (que genera una excepción si la clave no existe) o la TryFindfunción, que devuelve un tipo de opción con un valor de Some <result>, para una búsqueda exitosa, o None, para una búsqueda fallida. Luego se puede utilizar la coincidencia de patrones para extraer el valor sin procesar del resultado, o se puede establecer un valor predeterminado.

deje que sallyNumber = números .[ "Sally Smart" ] // o deje que sallyNumber = números . Item ( "Sally Smart" )      

sea ​​sallyNumber = match numbers . TryFind ( "Sally Smart" ) con | Some ( number ) -> number | None -> "n/a"             

En ambos ejemplos anteriores, el sallyNumbervalor contendría la cadena "555-9999".

Debido a que F# es un lenguaje .NET, también tiene acceso a las características de .NET Framework , incluido el tipo (que se implementa como una tabla hash ), que es el tipo de matriz asociativa principal que se usa en C# y Visual Basic. Este tipo puede ser el preferido al escribir código que está destinado a funcionar con otros lenguajes en .NET Framework, o cuando se prefieren las características de rendimiento de una tabla hash sobre las de un árbol AVL.System.Collections.Generic.Dictionary<'TKey,'TValue>

La dictfunción proporciona un medio para crear de manera conveniente un diccionario .NET que no está destinado a ser mutado; acepta una secuencia de tuplas y devuelve un objeto inmutable que implementa IDictionary<'TKey,'TValue>.

deje que los números sean [ "Sally Smart" , "555-9999" ; "John Doe" , "555-1212" ; "J. Random Hacker" , "555-1337" ] |> dict             

Cuando se necesita un diccionario mutable, se puede llamar directamente al constructor de . Consulte el ejemplo de C# en esta página para obtener información adicional.System.Collections.Generic.Dictionary<'TKey,'TValue>

let números = Sistema . Colecciones . Genérico . Diccionario < cadena , cadena > () números . Agregar ( "Sally Smart" , "555-9999" ) números .[ "John Doe" ] <- "555-1212" números . Elemento ( "J. Hacker aleatorio" ) <- "555-1337"         

IDictionaryLas instancias tienen un indexador que se utiliza de la misma manera que Map, aunque el equivalente a TryFindes TryGetValue, que tiene un parámetro de salida para el valor buscado y un valor de retorno booleano que indica si se encontró la clave.

deje que sallyNumber = deje que mutable result = "" si números . TryGetValue ( "Sally Smart" , & result ) entonces result de lo contrario "n/a"              

F# también permite llamar a la función como si no tuviera ningún parámetro de salida y en su lugar devolviera una tupla que contiene su valor de retorno regular y el valor asignado al parámetro de salida:

deje que sallyNumber = match numbers . TryGetValue ( "Sally Smart" ) con | true , number -> number | _ -> "n/a"              

Un diccionario o mapa se puede enumerar utilizando Seq.map.

// recorrer la colección y mostrar cada entrada. números |> Seq . map ( fun kvp -> printfn "El número de teléfono de %O es %O" kvp . Key kvp . Value )         

Visual FoxPro implementa la asignación con la clase de colección.

mapping = NEWOBJECT ( "Collection" ) mapping.Add ( "Narcisos" , "flor2" ) && Add(objeto, clave) – la clave debe ser un carácter index = mapping.GetKey ( "flor2" ) && devuelve el valor del índice 1 object = mapping( "flor2" ) && devuelve "Narcisos" (obtener por clave) object = mapping(1) && devuelve "Narcisos" (obtener por índice)

GetKey devuelve 0 si no se encuentra la clave.

Go tiene soporte integrado a nivel de lenguaje para matrices asociativas, llamadas "mapas". El tipo de clave de un mapa solo puede ser un tipo booleano, numérico, de cadena, de matriz, de estructura, de puntero, de interfaz o de canal.

Un tipo de mapa se escribe:map[keytype]valuetype

Agregar elementos uno a uno:

agenda_telefonica := make ( map [ string ] string ) // crea un mapa vacío agenda_telefonica [ "Sally Smart" ] = "555-9999" agenda_telefonica [ "John Doe" ] = "555-1212" agenda_telefonica [ "J. Random Hacker" ] = "553-1337"          

Un mapa literal:

libreta_telefonica := mapa [ cadena ] cadena { "Sally Smart" : "555-9999" , "John Doe" : "555-1212" , "J. Random Hacker" : "553-1337" , }       

Iterando a través de un mapa:

// sobre las claves y los valores para clave, valor:= rango phone_book { fmt.Printf ( " Número para % s : % s \ n" , clave , valor ) }        // sobre solo claves para clave := rango agenda telefónica { fmt . Printf ( "Nombre: %s\n" , clave ) }      

El lenguaje de programación Haskell proporciona solo un tipo de contenedor asociativo: una lista de pares:

m = [( "Sally Smart" , "555-9999" ), ( "John Doe" , "555-1212" ), ( "J. Hacker aleatorio" , "553-1337" )]       principal = imprimir ( buscar "John Doe" m )     

producción:

Sólo "555-1212"

Tenga en cuenta que la función de búsqueda devuelve un valor "Tal vez", que es "Nada" si no se encuentra, o "Solo 'resultado ' " cuando se encuentra.

El compilador Glasgow Haskell (GHC), la implementación de Haskell más utilizada, ofrece dos tipos más de contenedores asociativos. Otras implementaciones también pueden ofrecerlos.

Uno de ellos son los mapas funcionales polimórficos (representados como árboles binarios equilibrados inmutables):

importar Data.Map calificado como M     m = M . insertar "Sally Smart" "555-9999" M . vacío m' = M . insertar "John Doe" "555-1212" m m'' = M . insertar "J. Random Hacker" "553-1337" m'               principal = imprimir ( M . buscar "John Doe" m'' :: Tal vez String )        

producción:

Sólo "555-1212"

También existe una versión especializada para claves enteras llamada Data.IntMap.

Finalmente, una tabla hash polimórfica:

Importar datos calificados.HashTable como H    principal = do m <- H . nuevo ( == ) H . cadena hash H . insertar m "Sally Smart" "555-9999" H . insertar m "John Doe" "555-1212" H . insertar m "J. Hacker aleatorio" "553-1337" foo <- H . búsqueda m "John Doe" imprimir foo                          

producción:

Sólo "555-1212"

Tanto las listas de pares como los mapas funcionales proporcionan una interfaz puramente funcional, que es más idiomática en Haskell. Por el contrario, las tablas hash proporcionan una interfaz imperativa en la mónada IO .

En Java, las matrices asociativas se implementan como "mapas", que forman parte del marco de colecciones de Java . Desde J2SE 5.0 y la introducción de genéricos en Java, las colecciones pueden tener un tipo especificado; por ejemplo, una matriz asociativa que asigna cadenas a cadenas podría especificarse de la siguiente manera:

Mapa < String , String > phoneBook = new HashMap < String , String > (); phoneBook . put ( "Sally Smart" , "555-9999" ); phoneBook . put ( "John Doe" , "555-1212" ); phoneBook . put ( "J. Random Hacker" , "555-1337" );         

El getmétodo se utiliza para acceder a una clave; por ejemplo, el valor de la expresión phoneBook.get("Sally Smart")es "555-9999". Este código utiliza un mapa hash para almacenar la matriz asociativa, llamando al constructor de la HashMapclase. Sin embargo, dado que el código solo utiliza métodos comunes a la interfaz Map, se podría utilizar un árbol binario autoequilibrado llamando al constructor de la TreeMapclase (que implementa la subinterfaz SortedMap), sin cambiar la definición de la phoneBookvariable, ni el resto del código, ni utilizar otras estructuras de datos subyacentes que implementen la Mapinterfaz.

La función hash en Java, utilizada por HashMap y HashSet, la proporciona el Object.hashCode()método . Dado que cada clase en Java hereda de Object, cada objeto tiene una función hash. Una clase puede anular la implementación predeterminada de hashCode()para proporcionar una función hash personalizada más acorde con las propiedades del objeto.

La Objectclase también contiene el equals(Object)método que prueba la igualdad de un objeto con otro objeto. Las estructuras de datos con hash en Java se basan en que los objetos mantengan el siguiente contrato entre sus métodos hashCode()y equals():

Para dos objetos a y b ,

a . igual a ( b ) == b . igual a ( a ) si a . igual a ( b ), entonces a . hashCode () == b . hashCode ()       

Para mantener este contrato, una clase que anula equals()también debe anular hashCode(), y viceversa, de modo que hashCode()se base en las mismas propiedades (o un subconjunto de las propiedades) que equals().

Otro contrato que una estructura de datos hash tiene con el objeto es que los resultados de los métodos hashCode()y equals()no cambiarán una vez que el objeto se haya insertado en el mapa. Por este motivo, generalmente es una buena práctica basar la función hash en propiedades inmutables del objeto.

De manera análoga, TreeMap y otras estructuras de datos ordenados requieren que se defina un ordenamiento en el tipo de datos. O bien el tipo de datos ya debe haber definido su propio ordenamiento, mediante la implementación de la Comparableinterfaz; o bien se debe proporcionar uno personalizado Comparatoren el momento en que se construye el mapa. Al igual que con HashMap mencionado anteriormente, el ordenamiento relativo de las claves en un TreeMap no debe cambiar una vez que se hayan insertado en el mapa.

JavaScript (y su versión estandarizada, ECMAScript ) es un lenguaje orientado a objetos basado en prototipos .

El JavaScript moderno maneja matrices asociativas, utilizando las clases Mapy WeakMap. Un mapa no contiene ninguna clave de forma predeterminada; solo contiene lo que se le introduce explícitamente. Las claves y los valores pueden ser de cualquier tipo (incluidas funciones, objetos o cualquier primitivo).

Se puede inicializar un mapa con todos los elementos durante la construcción:

const phoneBook = new Mapa ([ [ "Sally Smart" , "555-9999" ], [ "John Doe" , "555-1212" ], [ "J. Random Hacker" , "553-1337" ], ]);          

Alternativamente, puede inicializar un mapa vacío y luego agregar elementos:

const phoneBook = new Map (); phoneBook . set ( "Sally Smart" , "555-9999" ); phoneBook . set ( "John Doe" , "555-1212" ); phoneBook . set ( "J. Random Hacker" , "553-1337" );       

El acceso a un elemento del mapa se puede realizar con el getmétodo:

const sallyNumber = phoneBook . get ( "Sally Smart" );   

En este ejemplo, el valor sallyNumberahora contendrá la cadena "555-9999".

Las claves de un mapa están ordenadas. Por lo tanto, al iterarlo, un objeto de mapa devuelve las claves en el orden de inserción. A continuación, se muestra la enumeración mediante un bucle for:

// recorrer la colección y mostrar cada entrada. for ( const [ name , number ] of phoneBook ) { console . log ( `El número de teléfono para ${ name } es ${ number } ` ); }       

Una llave se puede quitar de la siguiente manera:

agenda telefónica .delete ( "Sally Smart" ) ;

Un objeto es similar a un mapa: ambos permiten establecer claves en valores, recuperar esos valores, eliminar claves y detectar si un valor está almacenado en una clave. Por este motivo (y porque no había alternativas integradas), históricamente los objetos se han utilizado como mapas.

Sin embargo, existen diferencias importantes que hacen que un mapa sea preferible en ciertos casos. En JavaScript, un objeto es una asignación de nombres de propiedades a valores, es decir, una matriz asociativa con una salvedad: las claves de un objeto deben ser una cadena o un símbolo (se permiten objetos nativos y primitivos convertidos implícitamente a claves de cadena). Los objetos también incluyen una característica no relacionada con las matrices asociativas: un objeto tiene un prototipo, por lo que contiene claves predeterminadas que podrían entrar en conflicto con claves definidas por el usuario. Por lo tanto, realizar una búsqueda de una propiedad apuntará la búsqueda a la definición del prototipo si el objeto no define la propiedad.

Un objeto literal se escribe como { property1: value1, property2: value2, ... }. Por ejemplo:

const myObject = { "Sally Smart" : "555-9999" , "John Doe" : "555-1212" , "J. Hacker aleatorio" : "553-1337" , };         

Para evitar que la búsqueda utilice las propiedades del prototipo, puede utilizar la Object.setPrototypeOffunción:

Objeto .setPrototypeOf ( myObject , null ) ; 

A partir de ECMAScript 5 (ES5), el prototipo también se puede omitir mediante Object.create(null):

const myObject = Object . create ( null );   Objeto . asignar ( miObjeto , { "Sally Smart" : "555-9999" , "John Doe" : "555-1212" , "J. Random Hacker" : "553-1337" , });       

Si el nombre de la propiedad es un identificador válido, se pueden omitir las comillas, por ejemplo:

const miOtroObjeto = { foo : 42 , bar : falso };        

La búsqueda se escribe utilizando notación de acceso a propiedades, ya sea corchetes, que siempre funcionan, o notación de puntos, que solo funciona para claves de identificador:

miObjeto [ "John Doe" ] miOtroObjeto . foo

También puede recorrer todas las propiedades enumerables y los valores asociados de la siguiente manera (un bucle for-in):

para ( const propiedad en myObject ) { const valor = myObject [ propiedad ]; console . log ( `myObject[ ${ propiedad } ] = ${ valor } ` ); }          

O (un bucle for-of):

para ( const [ propiedad , valor ] de Object . entradas ( myObject )) { console . log ( ` ${ propiedad } = ${ valor } ` ); }       

Una propiedad se puede eliminar de la siguiente manera:

eliminar miObjeto [ "Sally Smart" ]; 

Como se mencionó anteriormente, las propiedades son cadenas y símbolos. Dado que cada objeto nativo y primitivo se puede convertir implícitamente en una cadena, puede hacer lo siguiente:

myObject [ 1 ] // la clave es "1"; tenga en cuenta que myObject[1] == myObject["1"] myObject [[ "a" , "b" ]] // la clave es "a,b" myObject [{ toString () { return "hola mundo" ; } }] // la clave es "hola mundo"          

En el JavaScript moderno, se considera de mala educación utilizar el tipo Array como una matriz asociativa. Existe consenso en que el tipo Object y las clases Map/ WeakMapson las mejores para este propósito. El razonamiento detrás de esto es que si Array se extiende a través de prototipos y Object se mantiene prístino, los bucles for y for-in funcionarán como se espera en "matrices" asociativas. Este problema ha salido a la luz debido a la popularidad de los marcos de JavaScript que hacen un uso intensivo y, a veces, indiscriminado de prototipos para extender los tipos incorporados de JavaScript.

Consulte el Día de concientización sobre prototipos de objetos y matrices de JavaScript para obtener más información sobre el tema.

En Julia , las siguientes operaciones gestionan matrices asociativas.

Declarar diccionario:

directorio telefónico = Dict ( "Sally Smart" => "555-9999" , "John Doe" => "555-1212" , "J. Random Hacker" => "555-1337" )            

Elemento de acceso:

directorio telefónico [ "Sally Smart" ]

Añadir elemento:

directorio telefónico [ "Nuevo contacto" ] = "555-2222"  

Eliminar elemento:

¡Borrar! ( guía telefónica , "Sally Smart" ) 

Obtener claves y valores como iterables :

claves ( agenda telefónica ) valores ( agenda telefónica )

En KornShell 93 y shells compatibles (ksh93, bash4...), se pueden utilizar las siguientes operaciones con matrices asociativas.

Definición:

typeset  -A  agenda telefónica ; # ksh93; en bash4+, "typeset" es un sinónimo del más preferido "declare", que funciona de forma idéntica en este caso agenda telefónica =([ "Sally Smart" ]= "555-9999" [ "John Doe" ]= "555-1212" [ "[[J. Random Hacker]]" ]= "555-1337" ) ;   

Desreferenciar:

${ agenda telefónica [ "John Doe" ] } ;

Lisp fue concebido originalmente como un lenguaje de "procesamiento de listas", y uno de sus tipos de datos más importantes es la lista enlazada, que puede tratarse como una lista de asociación ("alist").

' (( "Sally Smart" . "555-9999" ) ( "John Doe" . "555-1212" ) ( "J. Random Hacker" . "553-1337" ))        

La sintaxis (x . y)se utiliza para indicar un par de consmatrices asociativas . Las claves y los valores no necesitan ser del mismo tipo dentro de una lista. Lisp y Scheme proporcionan operadores como este assocpara manipular listas de forma similar a las matrices asociativas.

Existe un conjunto de operaciones específicas para el manejo de listas de asociaciones para Common Lisp , y cada una de ellas funciona de forma no destructiva.

Para agregar una entrada aconsse utiliza la función que crea y devuelve una nueva lista de asociación. Una lista de asociación en Common Lisp imita una pila, es decir, se adhiere al principio de último en entrar, primero en salir (LIFO) y, por lo tanto, se antepone al encabezado de la lista.

( let (( directorio telefónico NIL )) ( setf directorio telefónico ( acons "Sally Smart" "555-9999" directorio telefónico )) ( setf directorio telefónico ( acons "John Doe" "555-1212" directorio telefónico )) ( setf directorio telefónico ( acons "J. Random Hacker" "555-1337" directorio telefónico )))                    

Esta función puede interpretarse como una adaptación a conslas operaciones. ^[6]

;; El efecto de ;; (cons (cons CLAVE VALOR) ALIST) ;; es equivalente a ;; (acons CLAVE VALOR ALIST) ( let (( phone-book ' (( "Sally Smart" . "555-9999" ) ( "John Doe" . "555-1212" )))) ( cons ( cons "J. Random Hacker" "555-1337" ) phone-book ))            

Por supuesto, la operación destructiva pushtambién permite insertar entradas en una lista de asociación, debiendo cada entrada constituir una clave-valor cons para conservar la validez del mapeo.

( push ( cons "Dummy" "123-4567" ) guía telefónica )    

La búsqueda de una entrada por su clave se realiza mediante assoc, que puede configurarse para el predicado de prueba y la dirección, especialmente la búsqueda en la lista de asociaciones desde el final hasta el principio. El resultado, si es positivo, devuelve la entrada completa cons, no solo su valor. Si no se obtiene una clave coincidente, se devuelve el NILvalor.

( directorio telefónico de la asociación "John Doe" : prueba #' cadena= )    

Dos generalizaciones de assocexist: assoc-ifespera una función de predicado que prueba la clave de cada entrada, devolviendo la primera entrada para la cual el predicado produce un NILvalor distinto al invocarse. assoc-if-notinvierte la lógica, aceptando los mismos argumentos, pero devolviendo la primera entrada que genera NIL.

;; Encuentra la primera entrada cuya clave sea igual a "John Doe". ( assoc-if #' ( lambda ( key ) ( string= key "John Doe" )) phone-book )      ;; Encuentra la primera entrada cuya clave no sea ni "Sally Smart" ni "John Doe" ( assoc-if-not #' ( lambda ( key ) ( member key ' ( "Sally Smart" "John Doe" ) :test #' string= )) phone-book )         

El proceso inverso, la detección de una entrada por su valor, utiliza rassoc.

;; Buscamos la primera entrada con un valor de "555-9999". ;; Probamos los valores de la cadena de entrada con el predicado "string=". ( rassoc "555-9999" phone-book :test #' string= )    

Las generalizaciones correspondientes rassoc-ifexisten rassoc-if-not.

;; Encuentra la primera entrada cuyo valor sea "555-9999". ( rassoc-if #' ( lambda ( valor ) ( string= valor "555-9999" )) agenda-telefonica )      ;; Encuentra la primera entrada cuyo valor no sea "555-9999". ( rassoc-if-not #' ( lambda ( value ) ( string= value "555-9999" )) phone-book )      

Todas las funciones de búsqueda de entradas anteriores se pueden reemplazar por variantes generales centradas en listas, como find, find-if, find-if-not, así como funciones pertinentes como positiony sus derivados.

;; Busque una entrada con la clave "John Doe" y el valor "555-1212". ( find ( cons "John Doe" "555-1212" ) phone-book :test #' equal )      

La eliminación, a falta de un equivalente específico, se basa en las facilidades de la lista, incluidas las destructivas.

;; Crea y devuelve una lista al sin ninguna entrada cuya clave sea igual a "John Doe". ( remove-if #' ( lambda ( entry ) ( string= ( car entry ) "John Doe" )) phone-book )       

La iteración se realiza con la ayuda de cualquier función que espere una lista.

;; Iterar a través de "mapa". ( mapa NIL #' ( lambda ( entrada ) ( destructuring-bind ( clave . valor ) entrada ( formato T "~&~s => ~s" clave valor ))) libreta-telefonica )              ;; Iterar a través de "dolist". ( dolist ( entrada libreta-telefonica ) ( destructuring-bind ( clave . valor ) entrada ( formato T "~&~s => ~s" clave valor )))            

Al ser listas estructuradas, se pueden aplicar operaciones de procesamiento y transformación sin restricciones.

;; Devuelve un vector de los valores de la "libreta telefónica". ( map 'vector #' cdr libreta telefónica )   ;; Modificar destructivamente la "guía telefónica" mediante "map-into". ( map-into guía telefónica #' ( lambda ( entrada ) ( destructuring-bind ( clave . valor ) entrada ( cons ( reverse clave ) ( reverse valor )))) guía telefónica )              

Debido a su naturaleza lineal, las listas de asociaciones se utilizan para conjuntos de datos relativamente pequeños. Common Lisp también admite un tipo de datos de tabla hash y, para Scheme, se implementan en SRFI 69. Las tablas hash tienen una mayor sobrecarga que las listas de asociaciones, pero proporcionan un acceso mucho más rápido cuando hay muchos elementos. Otra característica es el hecho de que las tablas hash de Common Lisp no mantienen, a diferencia de las listas de asociaciones, el orden de inserción de las entradas.

Las tablas hash de Common Lisp se construyen mediante la make-hash-tablefunción , cuyos argumentos incluyen, entre otras configuraciones, un predicado para probar la clave de entrada. Si bien se toleran objetos arbitrarios, incluso la heterogeneidad dentro de una única instancia de tabla hash, la especificación de esta :testfunción clave se limita a entidades distinguibles: el estándar Common Lisp solo exige el soporte de eq, eql, equaly equalp, pero designa operaciones adicionales o personalizadas como permisibles para implementaciones concretas.

( let (( directorio-telefónico ( make-hash-table :test #' equal ))) ( setf ( gethash directorio-telefónico "Sally Smart" ) "555-9999" ) ( setf ( gethash directorio-telefónico "John Doe" ) "555-1212" ) ( setf ( gethash directorio-telefónico "J. Random Hacker" ) "553-1337" ))                   

La gethashfunción permite obtener el valor asociado a una clave.

( guía telefónica de "John Doe" de gethash )  

Además, se puede especificar un valor predeterminado para el caso de una tecla ausente.

( gethash "Incógnito" directorio telefónico 'no existe tal clave )   

Una invocación de gethashen realidad devuelve dos valores: el valor o valor sustituto de la clave y un indicador booleano, que retorna Tsi la tabla hash contiene la clave y NILpara señalar su ausencia.

( enlace-de-valor-múltiple ( valor contiene-clave ) ( gethash libreta telefónica "Sally Smart" ) ( si contiene-clave ( formato T "~& El valor asociado es: ~s" valor ) ( formato T "~& No se pudo encontrar la clave." )))              

Se utiliza remhashpara eliminar la entrada asociada a una clave.

( remhash de la guía telefónica de "J. Random Hacker" )  

clrhashvacía completamente la tabla hash.

( clrhash directorio telefónico ) 

La maphashfunción dedicada se especializa en iterar tablas hash.

( maphash #' ( lambda ( clave valor ) ( formato T "~&~s => ~s" clave valor )) libreta telefónica )         

Alternativamente, el loopconstructo prevé iteraciones, a través de claves, valores o conjunciones de ambos.

;; Itera las claves y valores de la tabla hash. ( bucle para clave que es la clave hash de la guía telefónica usando ( valor -hash valor ) hacer ( formato T "~&~s => ~s" clave valor ))                ;; Itera los valores de la tabla hash. ( bucle para valor siendo los valores hash de la libreta telefónica do ( imprimir valor ))          

Una opción adicional invoca with-hash-table-iterator, una macro creadora de iteradores, cuyo procesamiento debe ser controlado por el llamador.

( con iterador de tabla hash ( generador de entradas directorio telefónico ) ( bucle do ( enlace de valores múltiples ( tiene entrada clave valor ) ( generador de entradas ) ( si tiene entrada ( formato T "~&~s => ~s" clave valor ) ( fin de bucle )))))                 

Es fácil construir tipos de datos abstractos compuestos en Lisp, utilizando estructuras o características de programación orientada a objetos, junto con listas, matrices y tablas hash.

LPC implementa matrices asociativas como un tipo fundamental conocido como "mapa" o "mapeo", según el controlador. Las claves y los valores pueden ser de cualquier tipo. Un literal de mapeo se escribe como ([ key_1 : value_1, key_2 : value_2 ]). El código de procedimiento se ve así:

asignación de libreta_telefonica = ([]); libreta_telefonica [ "Sally Smart" ] = "555-9999" ; libreta_telefonica [ "John Doe" ] = "555-1212" ; libreta_telefonica [ "J. Random Hacker" ] = "555-1337" ;         

Se accede a las asignaciones para leer usando el operador de indexación de la misma manera que para escribir, como se muestra arriba. Por lo tanto, phone_book["Sally Smart"] devolvería la cadena "555-9999", y phone_book["John Smith"] devolvería 0. La prueba de presencia se realiza usando la función member(), por ejemploif(member(phone_book, "John Smith")) write("John Smith is listed.\n");

La eliminación se realiza mediante una función llamada m_delete() o map_delete(), según el controlador:m_delete(phone_book, "Sally Smart");

Los controladores LPC de la familia Amylaar implementan asignaciones multivalor utilizando un índice numérico secundario (otros controladores de la familia MudOS no admiten asignaciones multivalor). Sintaxis de ejemplo:

asignación de libreta_telefonica = ([ : 2 ]); libreta_telefonica [ "Sally Smart" , 0 ] = "555-9999" ; libreta_telefonica [ "Sally Smart" , 1 ] = "99 Sharp Way" ; libreta_telefonica [ "John Doe" , 0 ] = "555-1212" ; libreta_telefonica [ "John Doe" , 1 ] = "3 Nigma Drive" ; libreta_telefonica [ "J. Random Hacker" , 0 ] = "555-1337" ; libreta_telefonica [ "J. Random Hacker" , 1 ] = "77 Massachusetts Avenue" ;                     

Los controladores LPC lo suficientemente modernos como para soportar una construcción foreach() lo utilizan para iterar a través de sus tipos de mapeo.

En Lua , "tabla" es un tipo fundamental que puede utilizarse como una matriz (índice numérico, rápido) o como una matriz asociativa.

Las claves y los valores pueden ser de cualquier tipo, excepto nulo. A continuación, nos centraremos en los índices no numéricos.

Una literal de tabla se escribe como { value, key = value, [index] = value, ["non id string"] = value }. Por ejemplo:

phone_book  =  { [ "Sally Smart" ]  =  "555-9999" ,  [ "John Doe" ]  =  "555-1212" ,  [ "J. Random Hacker" ]  =  "553-1337" ,  -- Se permite una coma al final }aTable  =  { -- Tabla como valor subTable  =  {  5 ,  7.5 ,  k  =  true  },  -- la clave es "subTable" -- Función como valor [ 'John Doe' ]  =  función  ( edad )  si  edad  <  18  entonces  devuelve  "Joven"  de lo contrario  devuelve  "¡Viejo!"  fin  fin , -- La tabla y la función (y otros tipos) también se pueden usar como claves }

Si la clave es un identificador válido (no una palabra reservada), se pueden omitir las comillas. Los identificadores distinguen entre mayúsculas y minúsculas.

La búsqueda se escribe utilizando corchetes, que siempre funcionan, o notación de puntos, que solo funciona para claves de identificador:

imprimir ( aTable [ "John Doe" ]( 45 )) x  =  aTable . subTable . k

También puedes recorrer todas las claves y valores asociados con iteradores o bucles for:

simple  =  {  [ true ]  =  1 ,  [ false ]  =  0 ,  [ 3.14 ]  =  math.pi ,  x  =  'x' ,  [ "!" ]  =  42  } function  FormatElement ( clave ,  valor ) return  "["  ..  tostring ( clave )  ..  "] = "  ..  valor  ..  ", " end -- Itera sobre todas las claves table . foreach ( simple ,  function  ( k ,  v )  io.write ( FormatElement ( k ,  v ))  end ) print "" para  k ,  v  en  pares ( simple )  do  io.write ( FormatElement ( k ,  v ))  end print "" k =  nulo repeat k ,  v  =  next ( simple ,  k ) if  k  ~=  nulo  then  io.write ( FormatElement ( k ,  v ))  end Until  k  ==  nulo print ""

Se puede eliminar una entrada configurándola como nula:

simple . x  =  nulo

Asimismo, puedes sobrescribir valores o agregarlos:

simple [ '%' ]  =  "porcentaje" simple [ '!' ]  =  111

Mathematica y Wolfram Language utilizan la expresión Asociación para representar matrices asociativas. ^[7]

directorio telefónico = <| "Sally Smart" -> "555-9999" , "John Doe" -> "555-1212" , "J. Random Hacker" -> "553-1337" |> ;             

Para acceder: ^[8]

directorio telefónico [[ Tecla [ "Sally Smart" ]]]

Si las claves son cadenas, la palabra clave Key no es necesaria, por lo que:

directorio telefónico [[ "Sally Smart" ]]

Para listar las claves: ^[9] y los valores ^[10]

Llaves[guía telefónica]Valores[guía telefónica]

En MUMPS, cada matriz es una matriz asociativa. El soporte directo integrado a nivel de lenguaje para matrices asociativas se aplica a matrices privadas específicas de procesos almacenadas en memoria, denominadas "locales", así como a matrices globales permanentes y compartidas almacenadas en disco que están disponibles simultáneamente para varios trabajos. El nombre de las matrices globales está precedido por el acento circunflejo "^" para distinguirlas de las variables locales.

SET ^phonebook("Sally Smart")="555-9999" ;; almacenando datos permanentesSET phonebook("John Doe")="555-1212" ;; almacenando datos temporalesSET phonebook("J. Random Hacker")="553-1337" ;; almacenando datos temporalesMERGE ^phonebook=phonebook ;; copiando datos temporales en datos permanentes

Para acceder al valor de un elemento simplemente es necesario utilizar el nombre con el subíndice:

ESCRIBE "Número de teléfono :",^phonebook("Sally Smart"),!

También puedes recorrer una matriz asociada de la siguiente manera:

ESTABLECER NOMBRE=""PARA S NOMBRE=$ORDEN(^phonebook(NOMBRE)) SALIR:NOMBRE="" ESCRIBIR NOMBRE," Número de teléfono :",^phonebook(NOMBRE),!

Cocoa y GNUstep , escritos en Objective-C , manejan matrices asociativas usando NSMutableDictionary(una versión mutable de NSDictionary) la clase cluster. Esta clase permite asignaciones entre dos objetos cualesquiera. Se hace una copia del objeto clave antes de insertarlo en NSMutableDictionary, por lo tanto, las claves deben cumplir con el NSCopyingprotocolo. Cuando se inserta en un diccionario, el objeto de valor recibe un mensaje de retención para aumentar su recuento de referencias. El objeto de valor recibirá el mensaje de liberación cuando se elimine del diccionario (ya sea explícitamente o agregando al diccionario un objeto diferente con la misma clave).

NSMutableDictionary * aDictionary = [[ NSMutableDictionary alloc ] init ]; [ aDictionary setObject : @"555-9999" paraClave : @"Sally Smart" ]; [ aDictionary setObject : @"555-1212" paraClave : @"John Doe" ]; [ aDictionary setObject : @"553-1337" paraClave : @"Hacker aleatorio" ];             

Para acceder a los objetos asignados, se puede utilizar este comando:

id anObject = [ unDiccionario objetoParaClave : @"Sally Smart" ];    

Todas las claves o valores se pueden enumerar utilizando NSEnumerator:

NSEnumerator * keyEnumerator = [ aDictionary keyEnumerator ]; id key ; while (( key = [ keyEnumerator nextObject ])) { // ... procesarlo aquí ... }          

En Mac OS X 10.5+ y iPhone OS, las claves del diccionario se pueden enumerar de forma más concisa utilizando la NSFastEnumerationconstrucción: ^[11]

para ( id clave en un Diccionario ) { // ... procesarlo aquí ... }      

Lo que es aún más práctico es que se pueden crear fácilmente gráficos de datos estructurados utilizando Cocoa , especialmente NSDictionary( NSMutableDictionary). Esto se puede ilustrar con este ejemplo compacto:

NSDictionary * aDictionary = [ NSDictionary diccionarioConObjetosYClaves : [ NSDictionary diccionarioConObjetosYClaves : @"555-9999" , @"Sally Smart" , @"555-1212" , @"John Doe" , nil ], @"estudiantes" , [ NSDictionary diccionarioConObjetosYClaves : @"553-1337" , @"Hacker Aleatorio" , nil ], @"hackers" , nil ];                   

Se puede acceder rápidamente a los campos relevantes mediante rutas clave:

id unObjeto = [ unDiccionario valorParaRutaClave : @"estudiantes.Sally Smart" ];    

El lenguaje de programación OCaml ofrece tres contenedores asociativos diferentes. El más simple es una lista de pares:

#  let  m  =  [ "Sally Smart" ,  "555-9999" ; "Juan Pérez" ,  "555-1212" ; "J. Hacker aleatorio" ,  "553-1337" ];; val  m  :  ( cadena  *  cadena )  lista  =  [ ( "Sally Smart" ,  "555-9999" ); ( "Juan Pérez" ,  "555-1212" ); ( "J. Hacker aleatorio" ,  "553-1337" ) ] #  Lista . assoc  "Juan Pérez"  m ;; -  :  cadena  =  "555-1212"

La segunda es una tabla hash polimórfica:

#  let  m  =  Hashtbl . create  3 ;; val  m  :  ( ' _ a ,  ' _ b )  Hashtbl . t  =  < abstr > #  Hashtbl . add  m  "Sally Smart"  "555-9999" ;  Hashtbl . add  m  "John Doe"  "555-1212" ;  Hashtbl . add  m  "J. Random Hacker"  "553-1337" ;; -  :  unidad  =  () #  Hashtbl . find  m  "John Doe" ;; -  :  cadena  =  "555-1212"

El código anterior utiliza la función hash predeterminada de OCaml Hashtbl.hash, que se define automáticamente para todos los tipos. Para utilizar una función hash modificada, utilice la interfaz functor Hashtbl.Makepara crear un módulo, como con Map.

Finalmente, los mapas funcionales (representados como árboles binarios equilibrados inmutables):

#  módulo  StringMap  =  Map . Make ( String );; ... #  deja que  m  =  StringMap . add  "Sally Smart"  "555-9999"  StringMap . empty  deja que  m  =  StringMap . add  "John Doe"  "555-1212"  m  deja que  m  =  StringMap . add  "J. Random Hacker"  "553-1337"  m ;; val  m  :  string  StringMap . t  =  < abstr > #  StringMap . find  "John Doe"  m ;;  -  :  string  =  "555-1212"

Tenga en cuenta que para utilizar Map, debe proporcionar al functor Map.Makeun módulo que defina el tipo de clave y la función de comparación. La biblioteca de terceros ExtLib proporciona una versión polimórfica de mapas funcionales, llamada PMap, ^[12] a la que se le asigna una función de comparación al momento de su creación.

Tanto las listas de pares como los mapas funcionales proporcionan una interfaz puramente funcional. Por el contrario, las tablas hash proporcionan una interfaz imperativa. Para muchas operaciones, las tablas hash son significativamente más rápidas que las listas de pares y los mapas funcionales.

This section needs additional citations for verification. Please help improve this article by adding citations to reliable sources in this section. Unsourced material may be challenged and removed. (February 2011) (Learn how and when to remove this message)

El lenguaje de programación OptimJ es una extensión de Java 5. Al igual que Java, OptimJ proporciona mapas, pero OptimJ también proporciona matrices asociativas verdaderas. Las matrices de Java se indexan con números enteros no negativos; las matrices asociativas se indexan con cualquier tipo de clave.

Cadena [ Cadena ] phoneBook = { "Sally Smart" -> "555-9999" , "John Doe" -> "555-1212" , "J. Random Hacker" -> "553-1337" };            // String[String] no es un tipo Java sino un tipo Optimj: // matriz asociativa de cadenas indexadas por cadenas.// iterar sobre los valores para ( String número : phoneBook ) { System . println ( número ) ; }      // La declaración anterior imprime: "555-9999" "555-1212" "553-1337"// iterar sobre las claves para ( String name : phoneBook . keys ) { System . out . println ( name + " -> " + phoneBook [ name ] ); } // phoneBook[name] accede a un valor por una clave (parece un acceso a una matriz de Java) // es decir, phoneBook["John Doe"] devuelve "555-1212"          

Por supuesto, es posible definir matrices multidimensionales, mezclar matrices Java y matrices asociativas, mezclar mapas y matrices asociativas.

int [ Cadena ][][ doble ] a ; java . util . Map < Cadena [ Objeto ] , Entero > b ;   

Perl 5 tiene soporte integrado a nivel de lenguaje para matrices asociativas. El Perl moderno se refiere a las matrices asociativas como hashes ; el término matriz asociativa se encuentra en documentación antigua, pero se considera algo arcaico. Los hashes de Perl 5 son planos: las claves son cadenas y los valores son escalares. Sin embargo, los valores pueden ser referencias a matrices u otros hashes, y el módulo estándar de Perl 5 Tie::RefHash permite utilizar hashes con claves de referencia.

Una variable hash se marca con un % sigilo para distinguirla de los tipos de datos escalares, de matriz y de otros. Un literal hash es una lista de clave-valor, y la forma preferida es usar =>el token de Perl, que es semánticamente casi idéntico a la coma y hace que la asociación clave-valor sea más clara:

mi %phone_book = ( 'Sally Smart' => '555-9999' , 'John Doe' => '555-1212' , 'J. Random Hacker' => '553-1337' , );         

Para acceder a un elemento hash se utiliza la sintaxis $hash_name{$key}: la clave está entre llaves y el nombre del hash tiene como prefijo $, lo que indica que el elemento hash en sí es un valor escalar, aunque sea parte de un hash. El valor de $phone_book{'John Doe'}es '555-1212'. El %sigilo solo se utiliza cuando se hace referencia al hash en su totalidad, como cuando se solicita keys %phone_book.

La lista de claves y valores se puede extraer utilizando las funciones integradas keysy values, respectivamente. Por ejemplo, para imprimir todas las claves de un hash:

foreach $nombre ( teclas % agenda_telefonica ) { imprimir $nombre , "\n" ; }      

Se pueden iterar pares (clave, valor) utilizando la eachfunción:

mientras (( $nombre , $número ) = each %phone_book ) { print 'Número para ' , $nombre , ': ' , $número , "\n" ; }           

Una "referencia" hash, que es un valor escalar que apunta a un hash, se especifica en forma literal utilizando llaves como delimitadores, con una sintaxis similar a la especificación de un literal hash:

mi $libreta_telefonica = { 'Sally Smart' => '555-9999' , 'John Doe' => '555-1212' , 'J. Random Hacker' => '553-1337' , };         

Se accede a los valores de una referencia hash mediante el operador de desreferenciación:

imprimir $phone_book -> { 'Sally Smart' }; 

Cuando es necesario hacer referencia al hash contenido en la referencia hash como un todo, como ocurre con la keysfunción, la sintaxis es la siguiente:

foreach $nombre ( keys % { $libreta_telefonica }) { print 'Número para ' , $nombre , ': ' , $libreta_telefonica -> { $nombre }, "\n" ; }         

Perl 6 , renombrado como "Raku", también tiene soporte integrado a nivel de lenguaje para matrices asociativas, que se conocen como hashes o como objetos que realizan la función "asociativa". Al igual que en Perl 5, los hashes predeterminados de Perl 6 son planos: las claves son cadenas y los valores son escalares. Se puede definir un hash para no convertir todas las claves en cadenas automáticamente: estos se conocen como "hashes de objeto", porque las claves de dichos hashes siguen siendo el objeto original en lugar de una conversión en cadena del mismo.

Una variable hash suele estar marcada con un % sigilo para distinguirla visualmente de los tipos de datos escalares, de matriz y de otro tipo, y para definir su comportamiento en la iteración. Un literal hash es una lista de clave-valor, siendo la forma preferida el uso del =>token de Perl, que hace que la asociación de clave-valor sea más clara:

mi  %libreta-telefonica = 'Sally Smart' => '555-9999' , 'John Doe' => '555-1212' , 'J. Random Hacker' => '553-1337' ,;

Para acceder a un elemento hash se utiliza la sintaxis %hash_name{$key}: la clave está entre llaves y el nombre del hash (tenga en cuenta que el sigilo no cambia, al contrario de Perl 5). El valor de %phone-book{'John Doe'}es '555-1212'.

La lista de claves y valores se puede extraer utilizando las funciones integradas keysy values, respectivamente. Por ejemplo, para imprimir todas las claves de un hash:

para  %phone-book .keys -> $name { decir $ name ; }

De forma predeterminada, al iterar a través de un hash, se obtienen pares clave-valor.

para  %phone-book -> $entry { decir  "Número para $entry.key(): $entry.value()" ; # usando funciones de interpolación extendidas}

También es posible obtener valores clave y valores de valor alternativos utilizando el kvmétodo:

para  %phone-book . kv -> $nombre , $número { decir  "Número para $nombre: $número" ;}

Raku no tiene ninguna referencia. Los hashes se pueden pasar como parámetros únicos que no se aplanan. Si desea asegurarse de que una subrutina solo acepte hashes, use el símbolo % en la firma.

sub  lista-libreta-telefonica ( %pb ) { para  %pb . kv -> $nombre , $numero { decir  "Número para $nombre: $numero" ; }}lista-libreta-telefonica ( %libreta-telefonica );

De acuerdo con la tipificación gradual , los hashes pueden estar sujetos a restricciones de tipo, confinando un conjunto de claves válidas a un tipo determinado.

# Define un hash cuyas claves sólo pueden ser números enteros (tipo "Int"). my  %numbersWithNames { Int };# Las claves deben ser números enteros, como en este caso. %numbersWithNames . push ( 1 => "one" );# Esto provocará un error, ya que las cadenas como claves no son válidas. %numbersWithNames . push ( "key" => "two" );

El tipo de matriz incorporado de PHP es, en realidad, una matriz asociativa. Incluso cuando se utilizan índices numéricos, PHP almacena internamente las matrices como matrices asociativas. ^[13] Por lo tanto, PHP puede tener matrices indexadas numéricamente de forma no consecutiva. Las claves deben ser de tipo entero (los números de punto flotante se truncan a entero) o de tipo cadena, mientras que los valores pueden ser de tipos arbitrarios, incluidos otros arreglos y objetos. Las matrices son heterogéneas: una única matriz puede tener claves de diferentes tipos. Las matrices asociativas de PHP se pueden utilizar para representar árboles, listas, pilas, colas y otras estructuras de datos comunes que no están integradas en PHP.

Una matriz asociativa se puede declarar utilizando la siguiente sintaxis:

$agenda telefónica  =  array (); $agenda telefónica [ 'Sally Smart' ]  =  '555-9999' ; $agenda telefónica [ 'John Doe' ]  =  '555-1212' ; $agenda telefónica [ 'J. Random Hacker' ]  =  '555-1337' ;// o$libreta telefónica  =  matriz (  'Sally Smart'  =>  '555-9999' ,  'John Doe'  =>  '555-1212' ,  'J. Random Hacker'  =>  '555-1337' , );// o, a partir de PHP 5.4$phonebook  =  [  'Sally Smart'  =>  '555-9999' ,  'John Doe'  =>  '555-1212' ,  'J. Random Hacker'  =>  '555-1337' , ];// o$phonebook [ 'contactos' ][ 'Sally Smart' ][ 'número' ]  =  '555-9999' ; $phonebook [ 'contactos' ][ 'John Doe' ][ 'número' ]  =  '555-1212' ; $phonebook [ 'contactos' ][ 'J. Random Hacker' ][ 'número' ]  =  '555-1337' ;

PHP puede recorrer una matriz asociativa de la siguiente manera:

foreach  ( $directorio telefónico  como  $nombre  =>  $número )  {  echo  'Número para ' ,  $nombre ,  ': ' ,  $número ,  " \n " ; }// Para el último ejemplo de matriz se usa así foreach  ( $phonebook [ 'contacts' ]  as  $name  =>  $num )  {  echo  'Name: ' ,  $name ,  ', number: ' ,  $num [ 'number' ],  " \n " ; }

PHP tiene un amplio conjunto de funciones para operar con matrices. ^[14]

Se pueden implementar matrices asociativas que pueden usar objetos como claves, en lugar de cadenas y números enteros, con la SplObjectStorageclase de la Biblioteca PHP Estándar (SPL). ^[15]

Pike tiene compatibilidad integrada con matrices asociativas, a las que se denomina asignaciones. Las asignaciones se crean de la siguiente manera:

mapping ( cadena : cadena ) libreta telefónica = ([ "Sally Smart" : "555-9999" , "John Doe" : "555-1212" , "J. Random Hacker" : "555-1337" ]);   

El acceso y la comprobación de la presencia en las asignaciones se realiza mediante el operador de indexación. Por lo tanto, phonebook["Sally Smart"]devolvería la cadena "555-9999"y phonebook["John Smith"]devolvería 0.

La iteración a través de un mapeo se puede realizar utilizando foreach:

foreach ( agenda telefónica ; cadena clave ; cadena valor ) { write ( "%s:%s \n " , clave , valor ); }       

O usando un objeto iterador:

Mapeo . Iterador i = get_iterator ( directorio telefónico ); while ( i -> índice ()) { write ( "%s:%s \n " , i -> índice (), i -> valor ()); i -> siguiente (); }