Remove from list the last object having the same key attribute as value

@param list Array of objects having key attribute comparable to value
@param {string} key
@param value
@return {*} Array of deleted item or false
974174
function removeKeyFromList(list, key, value) {
    for (var i = list.length - 1; i >= 0; i--) {
        if (list[i][key] == value) {
            return list.splice(i, 1); // remove from array
        }
    }
    return false;
}
854017
@Override
    public boolean remove(Object o)
    {
        int idx = indexOf((E) o);
        if (idx >= 0)
        {
            list.remove(idx);
            return true;
        }
        return false;
    }
936544
function removeFromList(imageIdIndex) {
    const index = stackPrefetch.indicesToRequest.indexOf(imageIdIndex);

    if (index > -1) {
      // Don't remove last element if imageIdIndex not found
      stackPrefetch.indicesToRequest.splice(index, 1);
    }
  }
541213
public V remove(Object key) {
        List<V> res = map.remove(key);
        if (res == null) {
            return null;
        }
        assert (!res.isEmpty());
        return res.iterator().next();
    }
1036606
def kremove(self, key, value=None):
        
        for item in self:
            if value is None:
                # Just pop the key if present,
                # otherwise return None
                # (shortcut to ignore the exception)
                item.pop(key, None)
            else:
                try:
                    # Use the key as a set
                    item[key].remove(value)
                    # If the set contains a single element
                    # just store the latter
                    if len(item[key]) == 1:
                        item[key] = item[key].pop()
                except KeyError:
                    # This happens when the item
                    # does not contain the key
                    pass
                except AttributeError:
                    # This happens when the key is not a set
                    # and shall be removed only if values match
                    if item[key] == value:
                        item.pop(key)
1199982
def remove(self, value):
        
        self._set.remove(value)
        self._list.remove(value)
847639
function getSetRemoveProperty (collection, property, value) {
		if (isUndefined(value)) {
			// get property of first element if there is one
			return collection[0] ? collection[0][property] : undefined;
		} else if (value !== null) {
			collection.forEach(element => element[property] = value)
		} else {
			collection.forEach(element => delete element[property])
			}

		return collection;
	}
1162977
function del(key, cb) {
  return type(key) != 'array'
    ? localForage.removeItem(key).then(wrap(cb), cb)
    : Promise.all(key.map(del)).then(wrap(cb), cb);
}
331489
@Override
    public V remove(Object key) {
        CachedValue<K, V> entry = map.remove(key);
        if (entry != null) {
            onValueRemove(entry);
            if (!isValueExpired(entry)) {
                return (V) entry.getValue();
            }
        }
        return null;
    }
130193
private boolean remove(List<String> list, String item) {
        if (null != list) {
            if (list.remove(item)) {
                this.num_items--;
                return true;
            }
        }
        return false;
    }
969865
def clear_list_value(self, value):
        
        # Don't go any further: this value is empty.
        if not value:
            return self.empty_value
        # Clean empty items if wanted
        if self.clean_empty:
            value = [v for v in value if v]
        return value or self.empty_value
816498
function(key) {
    // don't use ES6 "delete" because it will be annoying
    // to use in browsers that are not ES6 friendly;
    var keys = this.keys,
        values = this.values,
        guid = guidFor(key),
        value;

    if (values.hasOwnProperty(guid)) {
      keys.remove(key);
      value = values[guid];
      delete values[guid];
      return true;
    } else {
      return false;
    }
  }
173724
function remove(elementToRemove) {
	
		//If element to remove is invalid, just return the same data
        if (!elementToRemove)
            return new jslinq(this.items);
			
		//Define output array
		var outData = [];
        
        //Check every element of "items"
        for (var n = 0; n < this.items.length; n++) {
		
			//If current element the one to remove, continue
			//if (this.items[n] == elementToRemove)
			if (equals(this.items[n], elementToRemove))
				continue;
				
			//If no match, push element to out
			outData.push(this.items[n]);
        }

        //Return for chaining
        return new jslinq(outData);        
    }
487399
function removeSubKeyFromList(list, sub, key, value) {
    for (var i = list.length - 1; i >= 0; i--) {
        if (a4p.isDefined(list[i][sub]) && (list[i][sub][key] == value)) {
            return list.splice(i, 1); // remove from array
        }
    }
    return false;
}
264922
function(key, value) {
        this._removeRemove(this.sets.remove, key);
        var op = this._getOp(this.sets.adds, key);
        if (op) {
            op.add.push(value);
        } else {
            this.sets.adds.push({key: key, add: [value]});
        }
        return this;
    }
1139969
function cleanItem(value) {

        var newvalue = null;

        if (Array.isArray(value)) {

            if (value.indexOf("consumer") > -1) {
                value.forEach(function (key2) {
                    ids[key2] = "roles";
                });
            }

            newvalue = [];

            value.forEach(function (item) {
                newvalue.push(cleanItem(item));
            })

            return newvalue;
        }

        if ((typeof value !== "object") || (value == null)) {
            return value;
        }

        Object.keys(value).forEach(function (key) {

            if (key == "orgs") {
                Object.keys(value[key]).forEach(function (key2) {
                    ids[key2] = "orgs";
                });
            }

            if (key == "_temp") {
                return;
            } else if (key == "encData" || key == "signature" || key == "encPrivateKey" || key == "publicKey") {
                newvalue = newvalue || {};
                if (typeof newvalue !== "object") throw new Error("Not Object" + key)
                newvalue[key] = "..."
            } else {
                newvalue = newvalue || {};
                if (typeof newvalue !== "object") throw new Error("Not Object" + key)
                newvalue[key] = cleanItem(value[key])
            }
        });

        return newvalue;
    }
2363
function commutate(key, list) {
    _.each(list, function (v, k, l) {
        if (k === key) {
            l[key] = true
        }
        if (v === true && k !== key) {
            l[k] = false
        }
    })
}