oH := bkHash():New() 
  
  oH:Put('001', aa->Field10) 
  
  xVal := oH:Get('001', 'NotFound') 
  
  oH:Sum(cTabNr, zpl->R_16)                      // DB zarpl. 
  oH:Sum(cTabNr, -(zpl->R_DLT)                   // DB zarpl. 
  
  
 CLASS bkHash 
  
  VAR oHash 
  
  _METHOD New() 
  _METHOD Get( xKey, xVal ) 
  _METHOD Put( xKey, xVal ) 
  _METHOD Len() 
  _METHOD Del( xKey ) 
  _METHOD IsKey( xKey ) 
  _METHOD GetI( nElem, lArr ) 
  _METHOD Sum( xKey, xVal ) 
  
 ENDCLASS 
  
 METHOD New()                                               CLASS bkHash               
  ::oHash := hb_hash() 
 RETURN Self 
  
 METHOD Get( xKey, xDef )                                   CLASS bkHash  
 // IF hb_hHasKey( ::oHash, xKey ); RETURN ::oHash[xKey] 
 // ENDIF 
 RETURN hb_hGetDef( oHash, xKey, xDef) 
  
 METHOD Put( xKey, xVal )                                   CLASS bkHash 
 // ::oHash[xKey] := xVal 
   hb_hSet( ::oHash, xKey, xVal ) 
 RETURN .T. 
  
 METHOD Len()                                               CLASS bkHash 
 RETURN Len(::oHash) 
  
 METHOD Del( xKey )                                         CLASS bkHash 
  IF hb_hHasKey( ::oHash, xKey ); hb_hDel(::oHash, xKey) 
  ENDIF 
 RETURN NIL 
  
 METHOD IsKey( xKey )                                       CLASS bkHash 
 RETURN hb_hHasKey( ::oHash, xKey ) 
  
 METHOD GetI( nElem, lArr )                                 CLASS bkHash  
  IF empty(lArr); RETURN hb_hValueAt(::oHash, nElem) 
  ENDIF 
 RETURN { Hb_hKeyAt(::oHash, nElem), hb_hValueAt(::oHash, nElem) } 
  
 METHOD Sum( xKey, xVal )                                   CLASS bkHash 
 LOCAL aSum,i,k,t := valtype(xVal) 
  
  IF     t == "A" 
         k    := Len(xVal) 
         aSum := Self:Get( xKey, aFill(array(k), 0) ) 
         IF Len( aSum ) == k 
            AEVal(xVal, {|x,i| aSum[ i ]:= iif(ValType(x)=='N', aSum[ i ]+x, x) } ) 
         ELSE 
            aSum := xVal 
         ENDIF 
  ELSEIF t == "N" 
         aSum := ::Get( xKey, 0 ) 
         IF valtype(aSum) == "N"; aSum += xVal 
         ENDIF 
  ELSE 
         aSum := xVal 
  ENDIF 
  
 RETURN Self:Put(xKey, aSum)  
  
 /* 
 Интерфейс  
 ---------  
   hb_Hash( 1,2, ... , 5,6, ....)    -> oHash // Много по два 
   hb_hHasKey( oHash, xKey )         -> .T./.F. - наличие ключа 
   hb_hPos( oHash, xKey)             -> Позиция ключа 
   hb_hGet( oHash, xKey)             -> xValue  или ошибка 
   hb_hGetDef( oHash, xKey, xDef)    -> если есть то xValue иначе xDef 
                                        ошибка если oHash не то. 
   hb_hSet( oHash, xKey, xVal)       -> oHash добавляет или ставит 
  
   hb_hDel( oHash, xKey)             -> oHash     Удаляет 
   hb_hKeyAt( oHash, nPos)           -> xKey     С Ключ позиции              
   hb_hValueAt( oHash, nPos, xVal)   -> Значение с позиции 
   
   hb_hPairAt( oHash, nPos, [DstKey, DstVal] ) -> { xKey, xVal }  
                                     Если 3,4 параметры есть то замена 
                                     иначе вернёт текущее  
  
   hb_hDelAt( oHash, nPos)           -> oHash 
   hb_hKeys( oHash )                 ->  
   hb_hValues( oHash )               -> 
   hb_hClear( oHash )                -> oHash 
   hb_hFill( oHash, xVal)            -> oHash 
   hb_hClone( oHash )                -> oHash 
   hb_hCopy( oHashSource, oHashDest) -> oHashDest 
  
  
   hb_hMerge( oHashDest, oHashSource, bBlock | n ) -> oHashDest 
                                        Если есть bBlock то на каждом елементе 
                                        oHashDest выполняется 
                                        {|xKey, xVal, nPos|  ... } 
  
  
   hb_hEVal( oHash, bBlock, [nStart], [nCount] ) -> oHash 
                    bBlock  ==  {|xKey, xVal, nPos| ...} 
  
  
   hb_hScan( oHash, xVal, [nStart],[nCount], [lExact] ) -> nPos | 0 
  
   hb_hSort( oHash )                     -> oHash 
  
   // Режимы 
   hb_hCaseMath( oHash, lValue)          -> .T. / .F.  
                                            предыдущий Сравнение с учётом регистра 
  
   hb_hBinary( oHash, lValue)            -> .T. / .F.  
     
   hb_hAutoAdd( oHash, lValue | nValue ) ->  
                HB_HASH_AUTOADD_ALWAYS 
                HB_HASH_AUTOADD_ASSIGN 
  
   hb_hKeepOrder( oHash, lValue)         -> .T. / .F. 
  
   hb_hAllocate( oHash, nValue)          -> NIL 
   hb_hDefault( oHash, [xValue])         -> xValue   
                                             получить поставить умалчивоемое   
  
   Empty( oHash )                        -> .T. если размер == 0 
   Len( oHash )                          -> даёт размер Hash  
  
   hb_IsHash( oHash )                    -> .T./.F. 
   hb_IsNul( oHash )                     -> если длинна == 0 
    
 // ключ в Hash всегда уникальный 
 Ошибки 
  Всегда :   oHash не то  ( Base 1187 ) 
         nPos  не верное  ( Base 1123 )  
 */ 
 

 
 ... 
 LOCAL a,i,j 
 LOCAL oTotal := bkHash():New() 
 LOCAL oGroup := bkHash():New() 
 LOCAL oTovar := bkHash():New() 
  
  sele TOVAR 
  INDEX DtoS(DateDok)+VidOper ... 
 ... 
  SetScope(0, DtoS(date())+'30')   // документы реализации 
  SetScope(0, DtoS(date())+'30')   // за день 
  dbGotop() 
  DO WHILE ! eof() 
     oTotal:Sum('Kol_Sum'      , { 1, tovar->SUMMA }) 
     oGroup:Sum(tovar->KodGru  , { 1, tovar->KOLVO, tovar->SUMMA }) 
     oTovar:Sum(tovar->KodTovar, { 1, tovar->KOLVO, tovar->SUMMA }) 
     dbSkip(1) 
  ENDDO 
 ... 
  
 ? ' Отчет о продажах за день :',date() 
 ? '======================================================================' 
 a := oTotal:Get( 'Kol_Sum' ) 
 ? 'Всего: строк -', a[ 1 ], 'сумма -', a[ 2 ]  
 ? '======================================================================' 
 ? 'В том числе по группам:' 
   for i := 1 to len( oGroup ) 
       a := oGroup:GetI( i, .T. )  // return {KodGru,{...}} 
 ? 'группа -', a[ 1 ], 'строк -', a[ 2 ][ 1 ], 'кол-во -', a[ 2 ][ 2 ], 'сумма -', a[ 2 ][ 3 ] 
   next 
 ? '======================================================================' 
 ? 'В том числе по товару:' 
   for i := 1 to len( oTovar ) 
       a := oTovar:GetI( i, .T. )  // return {KodTovar,{...}} 
 ? 'товар -', a[ 1 ], 'строк -', a[ 2 ][ 1 ], 'кол-во -', a[ 2 ][ 2 ], 'сумма -', a[ 2 ][ 3 ] 
   next 
 ? '======================================================================'