delete hash

@param  hashKey
@param  key
@return boolean
342149
public function hDel($hashKey, $key = null)
    {
        if ($key) {
            return $this->redis->hDel($hashKey, $key);
        }

        return $this->redis->hDel($hashKey);
    }
479135
public String remove(final String key) {
        final String result = data.getValue(key);
        data.remove(key);
        return result;
    }
813441
public function delete(string $key): bool
    {
        //create file name
        $file = $this->dir.'/'.\sha1($key).'.php';

        //chek if file exist and delete
        if (\file_exists($file)) {
            \unlink($file);

            return true;
        }

        return false;
    }
1294591
def delete(key)
      header = self[key]
      @headers.reject! { |header| header.key == key } ? header : nil
    end
84575
public void delete(Key key) {
    if(key == null) {
      throw new NullPointerException("Key may not be null");
    }
    if(!membershipTest(key)) {
      throw new IllegalArgumentException("Key is not a member");
    }

    int[] h = hash.hash(key);
    hash.clear();

    for(int i = 0; i < nbHash; i++) {
      // find the bucket
      int wordNum = h[i] >> 4;          // div 16
      int bucketShift = (h[i] & 0x0f) << 2;  // (mod 16) * 4
      
      long bucketMask = 15L << bucketShift;
      long bucketValue = (buckets[wordNum] & bucketMask) >>> bucketShift;
      
      // only decrement if the count in the bucket is between 0 and BUCKET_MAX_VALUE
      if(bucketValue >= 1 && bucketValue < BUCKET_MAX_VALUE) {
        // decrement by 1
        buckets[wordNum] = (buckets[wordNum] & ~bucketMask) | ((bucketValue - 1) << bucketShift);
      }
    }
  }
541403
def delete(key)
      hashed_key = hash_key(key)
      unless (entry = @btree.get(hashed_key))
        return nil
      end

      if entry.is_a?(PEROBS::Array)
        entry.each_with_index do |ae, i|
          if ae.key == key
            self.entry_counter -= 1
            return entry.delete_at(i).value
          end
        end
      else
        return entry.value if entry.key == key
      end

      nil
    end
599593
@Override
    public V remove(Object key) {
        int index = key == null ? indexOfNull() : indexOf(key, key.hashCode());
        if (index >= 0) {
            return removeAt(index);
        }

        return null;
    }
37902
public function delete($key)
	{
		if(!$this->exists($key)) {
			return false;
		}

		unset($this->data[$key]);

		return true;
	}
282215
public boolean handleKeyDeletion(final String key) {

        if (m_keyset.getKeySet().contains(key)) {
            if (removeKeyForAllLanguages(key)) {
                m_keyset.removeKey(key);
                return true;
            } else {
                return false;
            }
        }
        return true;
    }
1060112
public void remove(String key) {
    Iterator<Pair<String, ArrayList<String>>> it = store.iterator();
    while (it.hasNext()) {
      String thisKey = it.next().first;
      if (key.equals(thisKey)) {
        it.remove();
        break;
      }
    }
  }
1160178
def delete(key)
      key = key.key if key.respond_to?(:key)

      unless (idx = @indicies[key]).nil?
        @indicies.delete(key)
        @indicies.each { |k,v| @indicies[k] = v -= 1 if v > idx }
        @lines.delete_at(idx)
      end
    end
890565
public static function hashRemove($name, $key) {
        try {
            self::getCache()->hashRemove($name, $key);
            self::release();
        } catch (\RuntimeException $e) {
            self::release();
            throw $e;
        } catch (\Error $e) {
            self::release();
            throw $e;
        }
    }
1299122
public final boolean remove(Object key) {
        java.util.Set subSet = getSubSet(key);
        synchronized (subSet) {
            return subSet.remove(key);
        } // synchronized (subSet).
    }
413353
@Override
    public void delete(Key key) {
	// TODO check whether this needs to be checked!!
	if (!contains(key)) {
	    return;
	}

	// if both children of root are black, set root to red
	if (!isRed(root.getLeft()) && !isRed(root.getRight())) {
	    root.setColor(RED);
	}

	root = delete(root, key);
	if (!isEmpty()) {
	    root.setParent(null);
	    root.setColor(BLACK);
	}
	// assert check();
    }
77172
public function delete($key)
    {
        if (!$object = $this->tryGetObject($key)) {
            return false;
        }

        try {
            $object->delete();
        } catch (DeleteError $deleteError) {
            return false;
        }

        return true;
    }
402641
public function delete($key)
    {
        $keys = explode('.', $key);
        $key_string = '';
        foreach ($keys as $i => $_key) {
            $key_string = $key_string . ((is_numeric($_key) || $_key === '') ? "[{$_key}]" : "['{$_key}']");
        }
        $script = sprintf('unset($this->_params%s);', $key_string);
        eval($script);
    }
366404
def delete(self, key):
        
        validate_is_bytes(key)

        self.root_hash = self._set(self.root_hash, encode_to_bin(key), b'')