Tipo de matriz associativa

Uma matriz associativa é um mapa ou tabela de consulta que consiste em uma coleção de chaves e seus valores associados. Há um mapeamento um-para-um entre um conjunto de chaves e valores. As matrizes associativas são suportadas por Perl, ksh93, e várias outras línguas.

As matrizes associativas são tipos de dados abstratos em Vue.As ações a seguir podem ser executadas em tipos de dados de matriz associativa.

• Chaves de ligação para um valor:

  Se a instância das teclas ainda não existir, esta ação adiciia uma chave ou conjunto de chaves juntamente com o valor associado para a matriz associativa. Caso contrário, esta ação substitui o valor antigo associado pelo novo valor. As chaves que não estão ligadas possuem um valor padrão de 0 para o tipo numerical , valor string vazio para o tipo string , ou um valor NULL para outros tipos de chave.

  A seguir exemplo explica chaves de ligação para um valor

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

  O muito primeiro uso de uma variável de matriz associativa configura o tipo das chaves, o tamanho da dimensão chave e o tipo do valor. Ele deve permanecer o mesmo em todos os outros lugares no script Vue .

  Para uma chave em ASO, você pode ligar um valor LIST concluindo as seguintes ações diferentes:

  1. Ao designar uma variável 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. Ao designar uma lista vazia devolvida por list() função construtora:

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

  3. Ao anexar uma lista ou valor integral

     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 */

• Desvincular uma chave ou um conjunto de chaves e excluir o valor associado: A função delete() é usada para remover chaves e valores de ligação da matriz associativa. Uma chave sem limite é atribuído um valor de 0 ou uma string vazia.
  A seguir exemplo explica como usar função delete para desvincular uma chave

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

  O primeiro argumento é o nome da variável de matriz associativa. O nome da variável da matriz deve ser seguido por N comma separada chaves, onde N é o tamanho da dimensão chave. Se você deseja apenas excluir um valor associado com base em dimensões chave diferente de N, você pode especificar ANY para essa dimensão chave. Por exemplo, para excluir todos os elementos que possuem a string "a" como a segunda dimensão, digite o seguinte comando.

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

  Todas as chaves na função delete() podem ser especificadas como ANY, nesse caso, todos os elementos da matriz associativa serão excluídos. Esta função retorna 0 se elementos correspondentes são encontrados e são excluídos. Caso contrário, a função delete() retorna um valor de 1.

• Encontrando o valor para um conjunto de chaves: Esta operação consulta valores que estão ligados a uma única chave ou a várias chaves.

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

  Um valor LIST para uma chave pode ser recuperado através da indexação da matriz associativa com a chave. Todas as funções LIST, sum(), min(), max(), count()e avg(), podem ser usadas em uma Lista em uma matriz Associativa. Você também pode atribuir uma lista em matriz associativa a uma variável LIST.

  Exemplo:

  /* 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"]) );  

• Verificar se existe uma chave ou conjunto de chaves: A função exists() verifica se a matriz associativa possui algum elemento que corresponda às chaves dadas. A função exists() retorna um valor 1 se um elemento é encontrado e a função retorna 0 se um elemento não for encontrado.
  A seguir código block verifica se uma chave ou conjunto de chaves existem.

  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 você especificar a palavra-chave ANY para uma dimensão de chave específica, a dimensão se torna insignificante para operação de busca. Todas as chaves na função exists() podem ser especificadas como ANY, nesse caso, a função exists() verificará se a Matriz Associativa possui algum elemento ou não.

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

• Operação de incremento e decretação: Esta operação pode ser usada para incrementar ou decretar os valores da matriz associativa. Para usar esta operação, você deve especificar um inteiro como o tipo de valor para a chave. Os exemplos a seguir mostram o uso da operação de incremento e decretação:

No exemplo 1, o valor que corresponde à chave ksh , incrementado e o valor incrementado é impresso.

No exemplo 2, o valor que corresponde a ksh é primeiro impresso e, em seguida, o valor é incrementado. A operação de decretação funciona da mesma forma. No entanto, a operação de incremento ou de decretação pode ser realizada apenas em matrizes associativas cujo tipo de valor é inteiro. A operação de incremento ou decretação também pode ser usada como um agregador, onde o tipo de valor da matriz associativa por padrão é configurado como inteiro. Por exemplo, em declaração de encontração, um [100] + + a primeira vez, a matriz associativa a é criada com o tipo de chave inteiro e o tipo de valor inteiro. O valor armazenado para chave 100 é 1. Entretanto, para a[100]--, -1 seria armazenado como o valor da chave 100. Ao se realizar operações de incremento ou decretação subsequentes para as mesmas matriz associativa a operações de incremento e decretação são realizadas no valor para a chave especificada.

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

• Conteúdo de impressão de uma matriz associativa: Esta operação imprime a chave e o valor associado dos elementos para uma matriz associativa. Você pode especificar as seguintes opções de impressão:

  Opção de impressão de matriz associativa	Descrição	Valores possíveis	Valor Padrão
  num-of-entries	Especifica para imprimir o primeiro número de pares de valor de chave.	n> =0. (Se 0, todas as entradas são exibidas.)	0
  tipo de classificação	Especifica a ordem de classificação.	SORT_TYPE_ASCEND, SORT_TYPE_DESCEND	SORT_TYPE_ASCEND
  sort-by	Especifica se deve classificar com base em chave ou valor.	SORT_BY_KEY, SORT_BY_VALUE	SORT_BY_KEY
  lista-valor	Especifica qual atributo LISTA para classificar ou quantize quando o valor da matriz associativa é o tipo de lista	USE_LIST_SUM, USE_LIST_MIN, USE_LIST_MAX, USE_LIST_COUNT, USE_LIST_AVG	USE_LIST_AVG
  sort-key-index	Especifica o índice chave (dimensão), com base no qual a saída será classificada.	--1 ou k, sendo 0 <= k < number_of_keys	0
  pilha-bruta	Especifica para imprimir o rastreio de pilha no formato de endereço da RAW.	STKTRC_NO_SYM	0

  Quando o flag sort-by é SORT_BY_KEY, SORT_BY_VALUE e a chave (dada por sort-key-index) e o valor par é de um tipo onde a classificação não pode ser feita, então a opção num-of-entries e outras opções de impressão são aplicadas à impressão do par de chave e valor individual, se aplicável. Por exemplo, se a classificação for por tipo de intervalo, a opção num-of-entries , e as outras opções de impressão são reservadas para slots de cada intervalo.

  As opções de impressão de matriz associativa padrão podem ser alteradas usando a função set_aso_print_options()na análise BEGIN.

  Exemplo:

  set_aso_print_options (10, SORT_TYPE_DESCEND|SORT_BY_VALUE);

  Como mostrado no exemplo, várias bandeiras podem ser fornecidas inserindo um vertical bar symbol entre elas.

  Nota: A opção sort-key-index não pode ser definida pela função set_aso_print_options() porque não pode ser generalizada para matrizes associativas de diferentes tamanhos de dimensão chave.

  A função print() imprime as chaves e o valor associado para todos os elementos ou um subconjunto de elementos da matriz associativa utilizando-se as opções de impressão padrão. Para substituir as opções de impressão padrão, você deve usar argumentos adicionais na função print() . Para obter mais informações sobre a função print() , consulte o tópico Vue funções .

  A função print() imprime os pares de chave e valor da matriz associativa, utilizando as opções de impressão padrão. Se você quiser visualizar os conteúdos da matriz associativa em um formato diferente, ele fornecerá a opção num-of-entries e as sinalizadores de opção de impressão como parâmetros adicionais para a função print() .

  Exemplo:

  /* 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]);
  

• A rotina clear() é usada para limpar as chaves e os valores associados para elementos da matriz associativa. A rotina clear() também é usada para redefinir o valor da chave matriz associada sem limpar as chaves. Se o subroutine clear() limpar com sucesso um ou mais elementos, ele retorna um 0, e a subroutine retornará 1 quando nenhum elemento for limpo.

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

  A rotina anterior com apenas um argumento do tipo matriz associativa limpa todos os pares de chaves presentes na matriz associativa contagem. Após a operação clara anterior, a matriz associativa count está vazia.

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

  A rotina clara anterior redefine o valor de todos os pares de chaves na matriz associativa sem limpar a chave. O valor padrão a seguir é redefinido com base no tipo de valor da matriz associativa:
  Para limpar elementos com chaves específicas, deve-se especificar as chaves no primeiro argumento. Além disso, para ignorar qualquer dimensão de chave específica (todos os valores dessa combinação de dimensão de chave específica), você pode especificar ANY. Se as chaves forem especificadas, todas as dimensões fundamentais da matriz associativa devem ser especificadas como valores genuínos do tipo de chave de correspondência ou ANY.

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

  Você pode especificar um segundo parâmetro na rotina clear() como RESET_VALUE. Se você especificar RESET_VALUE , as chaves da matriz associativa são retidas e somente os valores são reajustados.

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

  O RESET_VALUE é dependente do tipo do valor. A tabela a seguir exibe os tipos de dados e os valores padrão aos quais o tipo de dados é reajustado:

  Tipo	Valor Padrão
  Tipos integrais (int, long, short, long long)	0
  LIST	Vazio
  Foat e duplo	0.0000000
  Sequência	Vazio
  stktrace_t	Vazio
  probev_timestamp_t	0
  path_t	Vazio
  mac_addr_t	0
  ip_addr_t	0

• A operação Quantizeimprime as chaves e os valores da matriz associativa dada em um formato gráfico baseado na escalação linear dos valores.

  quantize(count);

  contagem é uma matriz associativa, e imprime os seguintes conteúdos:

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

Semelhante à função print() , você pode fornecer quantize() opções de impressão de função para substituir as opções de impressão padrão.

Exemplo:

/* 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 na matriz associativa: Esta operação imprime as chaves e os valores da matriz associativa dada em formato gráfico com base na escalação logarítmica dos valores.

  lquantize (count);

  Onde a contagem é uma matriz associativa iria imprimir os seguintes conteúdos:

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

Semelhante à função print() , você pode fornecer com lquantize() opções de impressão de função para substituir as opções de impressão padrão.

Exemplo:

/* 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

O exemplo a seguir mostra como usar uma matriz associativa:

Exemplo:

# 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();
}