获取属性，如果属性位于nodes中，在第一次获取对象时，如果不是Node
则使用S.all获取之，并且返回获得的node
@param {String} key
9413
function get(key){ 
    var type = this.getType(key);
    var ret  = this[type][key];

    //对于node集合，如果是string，则设置node
    if (type === 'nodes' && util.isString(ret)) {
      ret = this._setNode(key);
    } 

    return ret;
  }
5688
public V get(K[] key) {
        Node child = root.get(key[0]);
        if (child != null) {
            return child.getChild(key, 1);
        }
        return null;
    }
1277044
public static final void remove(String key) {
        Map<String, Object> ctx = CTX_HOLDER.get();
        if (ctx != null) {
            ctx.remove(key);
        }
    }
368235
public RedBlackTreeNode<Key, Value> floorNode(Key key) {
	if (isEmpty()) {
	    return null;
	}
	RedBlackTreeNode<Key, Value> x = floor(root, key);
	if (x == null) {
	    return null;
	} else {
	    return x;
	}
    }
614921
function(key){
    
        var current = this.item(key);

		if (current)
        {        
            //special case: removing first item
            if (this._head === current) {
	
                this._head = current.next;
                
                if (!this._head){
                    this._tail = null;
                } else {
                    this._head.prev = null;
                };
       
            //special case: removing last item
            } else if (this._tail === current) {
                this._tail = current.prev;
                this._tail.next = null;
            } else {
				current.prev.next = current.next;
				current.next.prev = current.prev;
            };

			this._length--;
			delete this._hash[key];
			        
            return current;            
        
        } else {
            return null;
        }
               
    }
168603
function (key, value) {
        'use strict';
        var obj;
        if (!isStr(key)) {
            throw new Error(confKeyStrMsg, 'config-manager');
        }
        if (key.indexOf('.') === -1) {
            conf[key] = value;
        } else {
            obj = getLastNodeKey(key, conf);
            obj.node[obj.key] = value;
        }
        return this;
    }
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;
      }
    }
  }
394720
public boolean containsKey(String key) {
    key = key.toLowerCase();
    key = key.trim();
    return map.containsKey(key);
  }
566978
public boolean containsKey(Object key) {
        Object k = maskNull(key);
        Object[] tab = table;
        int len = tab.length;
        int i = hash(k, len);
        while (true) {
            Object item = tab[i];
            if (item == k)
                return true;
            if (item == null)
                return false;
            i = nextKeyIndex(i, len);
        }
    }
928473
private static String stripKey(final String key) {
        int index = key.indexOf(".");
        if (index > 0) {
            return key.substring(0, index);
        }
        return null;
    }
297555
function (node, key) {
  'use strict';
  var i, k;

  if (node.key === key) {
    return node;
  } else {
    for (i = 0; i < node.children.length; i += 1) {
      k = slow_findKey(node.children[i], key);
      if (k) {
        return k;
      }
    }
  }
}
1183076
public void put(K[] key, V value) {
        Node child = root.get(key[0]);
        if (child == null) {
            child = new Node(key[0]);
            root.put(key[0], child);
        }
        child.addChild(key, value, 1);
    }
121400
function remove(...key) {
    const self = this;
	
    if(Array.isArray(key[0])) {
        key = key[0];
    }
    key.forEach(k => {
        self._f = self._f.filter(f => {
            return f !== k;
        });
    });
}
916455
function Node(tree, options) {
		this.tree = tree;
		if (options && options.parent) {this.parent = options.parent;}
		if (options && options.hasOwnProperty('key')) { this.key = options.key; }
		this.data = options && options.hasOwnProperty('value') ? [options.value] : [];
	}
393965
private void compact(final CharSequence key) {
        final int keyLength = key.length();
        TrieNode<V> currentNode = getRoot();
        TrieNode<V> lastInUseNode = currentNode;
        int lastInUseIndex = 0;

        for (int i = 0; i < keyLength && currentNode != null; i++) {
            if (currentNode.inUse) {
                lastInUseNode = currentNode;
                lastInUseIndex = i;
            }

            currentNode = currentNode.children.get(key.charAt(i));
        }

        currentNode = lastInUseNode;

        for (int i = lastInUseIndex; i < keyLength; i++) {
            currentNode = currentNode.children.remove(key.charAt(i)).unset();
        }
    }
371566
function (key, value) {
            if (!base.isString(key)) {
                var l = this.__heap.push(this.__makeNode(key, value));
                this.__upHeap(l - 1);
            } else {
                throw new TypeError("Invalid key");
            }
        }
997143
function (key) {
            var keys = Array.isArray(key) ? key : arguments;

            var input = self.input.all();
            var results = {};

            for (var i = 0; i < keys.length; i++) {
                results[keys[i]] = input[keys[i]];
            }

            return results;
        }