Does the collection contain a given key?

@param mixed $value
The data value
@param boolean $strict[optional]
Check the type too or not

@return boolean If the collection have the given value
505479
public function contains($value, $strict = TRUE)
    {
        return $this->containsIn($value, $strict, $this->all());
    }
721092
public static function isAlpha(array $set, $strict = true) {
        return static::every($set, function($value) use ($strict) {
            if (!is_string($value)) {
                return false;
            }

            if ($strict) {
                if (is_string($value) && is_numeric($value)) {
                    return false;
                }
            }

            return true;
        });
    }
935279
public static function toScalar($value, $strict = false)
    {
        if (is_scalar($value)) {
            return $value;
        }

        if (is_null($value)) {
            if (!$strict) {
                return $value;
            }
            throw new Exceptions\WrongParameterType(
                'Expected scalar or object with __toString method on strict mode, got ' . ValueDescriber::describe($value)
            );
        }

        return ToString::toString($value);
    }
199995
public function containsValue($value): bool {
        foreach ($this->array as $key => $val) {
            if (null === $val) {
                continue;
            }
            if (Comparator::equals($val, $value)) {
                return true;
            }
        }
        return false;
    }
922830
public function contains($key, $value)
    {
        return \in_array($value, $this->get($key, null, false));
    }
830239
public function filter($value) {

        if(in_array($value, $this->options["true"], true))
            return true;

        if(!$this->options["strict"])
            return (boolean)$value;

        return false;
    }
1203143
public function contains($value)
    {
        foreach (array_keys($this->dataPlaceHolder) as $key) {
            $data = $this->dataPlaceHolder[$key];
            if ($value === $data || ($data instanceof Comparable && $data->equals($value))) {
                return true;
            }
        }

        return false;
    }
913226
public function where($key, $value, bool $strict = true): ArrayCollection
    {
        return $this->filter(function ($item) use ($key, $value, $strict) {
            if (!isset($item[$key])) {
                return false;
            }

            return $strict ? $item[$key] === $value : $item[$key] == $value;
        });
    }
704214
public function setData( $key, $value = NULL, $strict = TRUE ){
		if( empty( $key ) )																			//  no valid data key defined
			throw new InvalidArgumentException( 'Data key is required' );							//  throw exception
		if( array_key_exists( $key, $this->data ) && $strict )										//  data key already has a value
			throw new RuntimeException( 'Data attribute "'.$key.'" is already set' );				//  throw exception
		if( !preg_match( '/^[a-z0-9:_-]+$/i', $key ) )												//  key is invalid
			throw new InvalidArgumentException( 'Invalid data key "'.$key.'"' );					//  throw exception

		if( $value === NULL || $value === FALSE ){													//  no value available
			if( array_key_exists( $key, $this->data ) )												//  data exists
				unset( $this->data[$key] );															//  remove attribute
		}
		else
		{
			if( is_string( $value ) || is_numeric( $value ) )										//  value is string or numeric
				if( preg_match( '/[^\\\]"/', $value ) )												//  detect injection
					throw new InvalidArgumentException( 'Invalid data attribute value' );			//  throw exception
			$this->attributes[$key]	= $value;														//  set attribute
		}
	}
1101849
public function matches(array $values, $strict = false)
    {
        if (empty($values)) {
            return false;
        }

        $claims = $this->getClaims();

        foreach ($values as $key => $value) {
            if (! $claims->has($key) || ! $claims->get($key)->matches($value, $strict)) {
                return false;
            }
        }

        return true;
    }
813998
private function check($value, $params) {
		return true === ($this -> strict === true ? ($value === $params[0]) : ($value == $params[0]));
	}
861765
public static function equals($value, $required, $strict = false)
    {
        return Validator::equals($value, $strict)->validate($required);
    }
49556
public function containsValue($value): bool {

        /**
         * @var string $arrayIndex
         * @var SinglyLinkedList $list
         */
        foreach ($this->bucket as $arrayIndex => $list) {
            /* $list is the first element in the bucket. The bucket
             * can contain max $maxSize entries and each entry has zero
             * or one nodes which can have zero, one or multiple
             * successors.
             */
            if ($list->containsValue($value)) {
                return true;
            }
        }
        /*
         * If no bucket contains the value then return false because
         * the searched value is not in the list.
         */
        return false;
    }
1309341
public static function contains($list, $value, $strict = false)
    {
        return static::some($list, function ($item) use ($value, $strict) {
            return $strict ? $item === $value : $item == $value;
        });
    }
950698
public static function isValidValue($value, $strict = false)
    {
        static::initialize();

        return (array_search($value, static::$constants, $strict) !== false);
    }
271634
public function search($value, bool $strict = false)
    {
        return array_search($value, $this->storage, $strict);
    }
737855
private function isCollection($property, $value)
    {
        if (!$value instanceof Collection) {
            $got = is_object($value) ? get_class($value) : gettype($value);

            throw new \InvalidArgumentException(
                sprintf('Value of "%s" property must be an instance of Collection, got %s.', $property, $got)
            );
        }
    }