Tipo di matrice associativa

Una matrice associativa è una tabella mappa o di ricerca costituita da una raccolta di chiavi e dai relativi valori associati. Esiste una mappatura one-to-one tra una serie di chiavi e valori. Gli array associativi sono supportati da Perl, ksh93e diverse altre lingue.

Gli array associativi sono tipi di dati astratti in Vue.Di seguito le azioni possono essere eseguite su tipi di dati array associativi.

• Chiavi di collegamento a un valore:

  Se l'istanza delle chiavi non esiste già, questa azione aggiunge una chiave o una serie di chiavi insieme al valore associato all'array associativo. In caso contrario, questa azione sostituisce il vecchio valore associato con il nuovo valore. I tasti che non sono legati hanno un valore predefinito di 0 per il tipo numerical , valore stringa vuoto per il tipo string o un valore NULL per altri tipi di chiavi.

  Di seguito esempio spiega le chiavi di collegamento a un valore

  /* single key dimension */
  count["ksh"] = 1;
  /* multiple key dimensions */
  var[0][“a”][2.5] = 1;
  var[1][“a”][3.5] = 2;

  Il primissimo utilizzo di una variabile array associativa imposta il tipo di chiavi, la dimensione della dimensione chiave e il tipo di valore. Deve rimanere lo stesso in tutti gli altri luoghi dello script Vue .

  Per una chiave in ASO è possibile legare un valore LIST completando le seguenti azioni diverse:

  1. Assegnando una variabile LIST:

        assoc_array["ksh"]=ll  /* copies ll list into associative array */
        assoc_array["ksh"]=assoc_array["abc"]; /* copies a list in ASO to another list in ASO.
                                                         Here the value type of assoc_array is LIST */ 

  2. Assegnando un elenco vuoto restituito dalla funzione costruttore list() :

     assoc_array["ksh"]=list(); /* assigns an empty list */ 

  3. Appendendo un elenco o un valore integrale

     append(assoc_array["ksh"], 5);	/* integral value 5 is appended to the list in ASO */
     append(assoc_array["ksh"], ll);	/* appends the contents of LIST variable ll to the list in ASO*/
     append(assoc_array["ksh"], assoc_array["abc"]); /* appends the contents of list in ASO to another list in ASO */

• Annullamento del collegamento di una chiave o di una serie di chiavi ed eliminazione del valore associato: la funzione delete() viene utilizzata per rimuovere le chiavi e i valori di collegamento dall'array associativo. A una chiave non legata viene assegnato un valore di 0 o una stringa vuota.
  Di seguito esempio spiega come utilizzare la funzione di cancellazione per svincolare una chiave

  delete(count, "ksh");
  delete(var, 0, “a”, 2.5);

  Il primo argomento è il nome della variabile array associativa. Il nome variabile schiera deve essere seguito da N chiavi separate da virgola, dove N è la dimensione della dimensione chiave. Se si desidera eliminare solo un valore associato sulla base di dimensioni chiave diverse da N, è possibile specificare ANY per quella dimensione chiave. Ad esempio, per eliminare tutti gli elementi che hanno la stringa "a" come seconda dimensione, inserire il seguente comando.

  delete(var, ANY, “a”, ANY);

  Tutte le chiavi in funzione delete() possono essere specificate come ANY, in tal caso tutti gli elementi dell'array associativo verranno cancellati. Questa funzione restituisce 0 se gli elementi corrispondenti vengono trovati e vengono cancellati. In caso contrario, la funzione delete() restituisce un valore di 1.

• Ricerca del valore per una serie di chiavi: Questa operazione guarda i valori che sono legati ad un singolo tasto o a più chiavi.

  total = count["ksh"] + count["csh"];
  prod = var[0][“a”][2.5] * var[1][“a”][3.5];

  Un valore ELENCA per una chiave può essere richiamato indicizzando l'array associativo con la chiave. Tutte le funzioni LIST, sum(), min(), max(), count()e avg(), possono essere utilizzate su un Elenco in una schiera associativa. È inoltre possibile assegnare un elenco in schiera associativa a una variabile LIST.

  Esempio:

  /* copies associative array list into list variable "ll" */
  ll=assoc_array["ksh"];
  /* prints the sum of all elements of list in associative array indexed with ksh" */
  printf("sum of assoc_array %d\n",sum(assoc_array["ksh"]) ); 
  /* prints the minimum value */
  printf("min of assoc_array %d\n",min(assoc_array["ksh"]) );
  /* prints the maximum value */
  printf("max of assoc_array %d\n",max(assoc_array["ksh"]) ); 
  /* prints the number of values in list */
  printf("count of assoc_array %d\n",count(assoc_array["ksh"]) );
  /* prints average value of the list */
  printf("avg of assoc_array %d\n",avg(assoc_array["ksh"]) );  

• Verifica se esiste una chiave o una serie di chiavi: la funzione exists() verifica se l'array associativo ha qualsiasi elemento che corrisponde alle chiavi date. La funzione exists() restituisce un valore 1 se si trova un elemento e la funzione restituisce 0 se un elemento non viene trovato.
  Dopo il blocco del codice si verifica se una chiave o una serie di chiavi esistono.

  if (exists(count, "ksh"))
    printf("Number of ksh calls = %d\n", count["ksh"]);
  if (exists(var, 0, “a”, 2.5))
    printf(“Found value = %d\n”, var[0][“a”][2.5]);
  

  Se si specifica la parola chiave ANY per una particolare dimensione chiave, la dimensione diventa insignificante per l'operazione di ricerca. Tutti i tasti della funzione exists() possono essere specificati come ANY, in tal caso la funzione exists() controllerà se l'Array Associativo ha qualsiasi elemento o meno.

  my_key = “a”;
  if (exists(var, ANY, my_key, ANY))
    printf(“Found element with second key as %s \n”, my_key);
  

• Operazione di incremento e decremento: Questa operazione può essere utilizzata per incrementare o decretare i valori di matrice associativa. Per utilizzare questa operazione è necessario specificare un numero intero come tipo di valore per la chiave. I seguenti esempi mostrano l'utilizzo dell'incremento e dell'operazione di decremento:

Ad esempio 1, viene stampato il valore che corrisponde al tasto ksh , incrementato e il valore incrementato.

Ad esempio 2, il valore che corrisponde a ksh viene prima stampato e poi il valore viene incrementato. L'operazione di decremento funziona allo stesso modo. Tuttavia, l'operazione di incremento o di decremento può essere eseguita solo su array associativi il cui tipo di valore è intero. L'operazione di incremento o di decremento può essere utilizzata anche come aggregatore, dove il tipo di valore dell'array associativo per impostazione predefinita è impostato come intero. Ad esempio, in occasione di incontri di incontri, un [ 100] + + la prima volta, l'array associativo a viene creato con il tipo di chiave intero e il tipo di valore intero. Il valore memorizzato per la chiave 100 è 1. Tuttavia, nel caso di a[100]--, -1 verrebbe memorizzato come valore della chiave 100. Al momento di incontrare successive operazioni di incremento o di decremento per le stesse operazioni di incremento e di decremento dell'array associativo a viene eseguito sul valore per la chiave specificata.

++var[0][“a”][2.5];
var[0][“a”][2.5]++;
--var[1][“a”][3.5];
var[1][“a”][3.5]--;

• Stampa contenuto di una matrice associativa: Questa operazione stampa la chiave e il valore associato degli elementi per una schiera associativa. È possibile specificare le seguenti opzioni di stampa:

  Opzione di stampa array associativo	Descrizione	Valori posibile	Valore predefinito
  num - di - voci	Specifica di stampare il primo numero di coppie chiave - valore.	n> =0. (Se 0, tutte le voci vengono visualizzate.)	0
  tipo - tipo	Specifica l'ordine di ordinamento.	SORT_TYPE_ASCEND, SORT_TYPE_DESCEND	SORT_TYPE_ASCEND
  ordina - per	Specifica se ordinare in base a chiave o valore.	SORT_BY_KEY, SORT_BY_VALUE	SORT_BY_KEY
  elenco - valore	Specifica quale attributo LIST ordinare o quantizzare quando il valore dell'array associativo è il tipo di elenco	USE_LIST_SUM, USE_LIST_MIN, USE_LIST_MAX, USE_LIST_COUNT, USE_LIST_AVG	USE_LIST_AVG
  ordinamento - chiave di ordinamento	Specifica l'indice chiave (dimensione), in base al quale verrà ordinato l'output.	--1 o k, dove 0 <= k < numero_di_chiavi	0
  stack - raw	Specifica di stampare la traccia di stack in formato indirizzo RAW.	STKTRC_NO_SYM	0

  Quando il tipo - per bandiera è SORT_BY_KEY, SORT_BY_VALUE e la chiave (data da ordina - indice - key - index) e la coppia di valore è di un tipo in cui lo smistamento non può essere effettuato, allora l'opzione num - of - entries e altre opzioni di stampa vengono applicate alla stampa della coppia di tasti e valore individuale, se applicabile. Ad esempio, se l'ordinamento è per tipo di intervallo, l'opzione num - of - entries e le altre opzioni di stampa sono riservate agli slot di ogni intervallo.

  Le opzioni di stampa dell'array associativo predefinito possono essere modificate utilizzando la funzione set_aso_print_options()nel probe BEGIN.

  Esempio:

  set_aso_print_options (10, SORT_TYPE_DESCEND|SORT_BY_VALUE);

  Come mostrato nell'esempio, possono essere fornite più bandiere inserendo un vertical bar symbol tra di essi.

  Nota: L'opzione sort-key-index non può essere impostata dalla funzione set_aso_print_options() perché non può essere generalizzata per array associativi di diverse dimensioni di dimensione chiave.

  La funzione print() stampa le chiavi e il valore associato per tutti gli elementi o un sottoinsieme di elementi dell'array associativo utilizzando le opzioni di stampa predefinite. Per sovrascrivere le opzioni di stampa predefinite è necessario utilizzare argomenti aggiuntivi nella funzione print() . Per ulteriori informazioni sulla funzione print() , consultare l'argomento FunzioniVue .

  La funzione print() stampa le coppie chiave e valore dell'array associativo utilizzando le opzioni di stampa predefinite. Se si desidera visualizzare il contenuto dell'array associativo in un formato diverso, fornirà l'opzione num - di - voci e gli indicatori dell'opzione di stampa come parametri aggiuntivi per la funzione print() .

  Esempio:

  /* uses default print options to display the contents of associative array ‘count’ */
  print(count); 	
  /* prints the first 10 entries of sorted associative array ‘count’. 
  Default sort-by and sort-type options are used */
  print(count, 10);	
  /* sorts the associative array ‘count’ in descending order of values and 
  displays the first 10 entries of ‘count’ */ 
  print(count, 10, SORT_BY_VALUE|SORT_TYPE_DESCEND);
  
  /* print elements which have first key as 0 */
  print(var[0][ANY][ANY]);
  

• La routine clear() viene utilizzata per cancellare le chiavi e i valori associati per gli elementi dell'array associativo. La routine clear() viene utilizzata anche per reimpostare il valore della chiave array associata senza cancellare le chiavi. Se la sottoroutine clear() chiarisce correttamente uno o più elementi, restituisce un 0 e la sottoroutine restituisce 1 quando non vengono sdoganati elementi.

  clear(count);               // count is an associative array.

  La routine precedente con un solo argomento del tipo di matrice associativa cancella tutte le coppie chiave presenti nella schiera associativa conta. Dopo la precedente operazione di chiara, la matrice associativa conta è vuota.

  clear(count, RESET_VALUE);       // count is an associative array. 
  clear(var);          //  var is an associative array with three key dimensions

  La precedente routine chiara riimposta il valore di tutte le coppie chiave nella schiera associativa senza cancellare la chiave. Il seguente valore predefinito viene reimpostato in base al tipo di valore dell'array associativo:
  Per elementi chiari con tasti specifici è necessario specificare le chiavi nel primo argomento. Inoltre, per ignorare qualsiasi dimensione chiave particolare (tutti i valori di quel determinato match di dimensione chiave) è possibile specificare ANY. Se vengono specificati i tasti, tutte le dimensioni chiave dell'array associativo devono essere specificate come valori genuini del tipo di chiave corrispondente o ANY.

  clear(var[ANY][“a”][ANY]);  // clear all elements with second key as “a”

  È possibile specificare un secondo parametro nella routine clear() come RESET_VALUE. Se si specifica RESET_VALUE , le chiavi dell'array associativo vengono mantenute e solo i valori vengono reimpostati.

  clear(count, RESET_VALUE);  
  clear(var[0][ANY][ANY], RESET_VALUE);
  

  Il RESET_VALUE dipende dal tipo di valore. La seguente tabella visualizza i tipi di dati e i valori predefiniti a cui il tipo di dati viene reimpostato:

  Tipo	Valore predefinito
  Tipi integrali (int, long, short, long long)	0
  LIST	Vuoto
  Foat e doppio	0.0000000
  Stringa	Vuoto
  stktrace_t	Vuoto
  probev_timestamp_t	0
  path_t	Vuoto
  mac_addr_t	0
  ip_addr_t	0

• L'operazione Quantizestampa le chiavi e i valori della schiera associativa data in formato grafico in base alla scalabilità lineare dei valori.

  quantize(count);

  count è una schiera associativa e stampa i seguenti contenuti:

  key                  value
  1                     1             ========
  2                     2             =========
  3                     3             ==========
  4                     4             ===========
  5                     5             ============
  6                     6             =============

Analogamente alla funzione print() , è possibile fornire le opzioni di stampa della funzione quantize() per sovrascrivere le opzioni di stampa predefinite.

Esempio:

/* sorts the associative array ‘count’ in descending order of values and displays 
the first 10 entries of ‘count’ in graphical format*/
quantize(count, 10, _BY_VALUE|SORT_TYPE_DESCEND);

quantize(var[0][ANY][ANY]);  //quantize elements with first key as 0

• Lquantize sulla schiera associativa: Questa operazione stampa le chiavi e i valori della schiera associativa data in formato grafico in base alla scalabilità logaritmica dei valori.

  lquantize (count);

  Dove il conteggio è una schiera associativa stamperebbe i seguenti contenuti:

  key                    value
  500                     500           ====
  1000                   1000           ====
  2000                   2000           =====
  4000                   4000           =====
  8000                   8000           ======
  16000                 16000           ======
  32000                 32000           =======
  64000                 64000           =======

Analogamente alla funzione print() , è possibile fornire le opzioni di stampa della funzione lquantize() per sovrascrivere le opzioni di stampa predefinite.

Esempio:

/* sorts the associative array ‘count’ in descending order of values, and displays 
the first 10 entries of ‘count’ in graphical 
format based on the logarithmic value*/
lquantize(count, 10, _BY_VALUE|SORT_TYPE_DESCEND);

lquantize(var[0][ANY][ANY]);  //lquantize elements with first key as 0

Il seguente esempio mostra come utilizzare una matrice associativa:

Esempio:

# Trace all the alloc- related calls and store the entry 
# Time in ‘entry_time’ associative array
#
@@uft:$__CPID:*:"/alloc/":entry
{
        entry_time[get_function()]=timestamp();
}
#
# At exit, first check if entry for this function was traced
# If so, delete the entry time from ‘entry_time’ associative array 
# To ensure that next time no action is taken on exit if entry was not traced. 

@@uft:$__CPID:*:"/alloc/":exit
{
   func =get_function();
   if(exists(entry_time, func) )
   {
             append(time_taken[func],
                   diff_time(timestamp(),entry_time[func],MICROSECONDS));
	            delete(entry_time, func);
	  }
}
#
# Print the list attributes sum, min, max, count, and avg time taken in every 
# Alloc function.
#
@@syscall:$__CPID:exit:entry
{
  print(time_taken);
	 exit();
}