Returns true if 'value' is found in array 'array'

Expected Params:
value string The item to search for in the array
array array  The array to search

@return boolean true if value is in array
433729
public function inArray()
    {
        $needle = $this->getParameter('value');
        $haystack = $this->getParameter('array');

        if($haystack instanceof Meta){
            $haystack = $haystack->getMetaValue();
        }

        if(is_string($haystack))
            $haystack = StringUtils::smartExplode($haystack);

        return in_array($needle, (array)$haystack);
    }
391179
protected function isNumericArray(array $value)
    {
        foreach (array_keys($value) as $key) {
            if (is_string($key)) {
                return false;
            }
        }

        return true;
    }
82247
public static function isArray($value)
    {
        return \is_array($value)
        || (\is_object($value) && $value instanceof \ArrayObject)
        || (\is_object($value) && $value instanceof \SplFixedArray);
    }
360001
public function find($item = null, $array = null)
    {
        if(is_null($item)) return null;

        if(strpos($item, '.')) {
            $arr = explode('.', $item);
            if(count($arr) > 2 ) {
                $itemToSearch = join('.', array_slice($arr, 1));
            }
            else {
                $itemToSearch = $arr[1];
            }
            return $this->findItemIn($itemToSearch, $arr[0]);
        }
        else {
            $array = !is_null($array) ? $array : $this->settings;
            foreach ($array as $key => $value) {
                if($key === $item) {
                    $this->currentItem = $value;
                    $this->found = true;
                    break;
                }
                else {
                    if(is_array($value)) {
                        $this->find($item, $value);
                    }
                }
            }
        }

        if(!$this->found) {
            return false;
        }
        return $this->currentItem;
    }
1290454
function in_array( needle, haystack )
	{
		var found = 0,
			key;
		for ( key in haystack )
		{
			if ( haystack[ key ] == needle )
			{
				found = 1;
				break;
			}
		}
		return found;
	}
617782
function searchNestedArray(array $array, $search, $mode = 'value') {
	
	    foreach (new RecursiveIteratorIterator(new RecursiveArrayIterator($array)) as $key => $value) {
	        if ($search === ${${"mode"}})
	            return true;
	    }
	    return false;
	}
652252
protected function _isMultilingualArray($value) {
        if (!is_array($value)) {
            return false;
        }
        $locales = Garp_I18n::getLocales();
        $keys = array_keys($value);
        sort($locales);
        sort($keys);

        return $locales === $keys;
    }
469364
function inArray(value, arr) {
    let len = arr.length;
    for (let i = 0; i < len; i++) {
        if (arr[i] == value) {
            return true;
        }
    }
    return false;
}
157929
def isin(value, values):
    
    for i, v in enumerate(value):
        if v not in np.array(values)[:, i]:
            return False
    return True
7394
protected function isValueSelected($value)
	{
		$val = $this->getValue();
		if (is_null($value)) {
			return FALSE;
		}
		elseif (is_array($val)) {
			return in_array($value, $val);
		}

		return $value == $val;
	}
301334
def non_empty_array?(value, uniqueness_check = true)
      result = value.is_a?(Array) && !value.empty?
      if uniqueness_check
        result && value.size == value.uniq.size
      else
        result
      end
    end
1021113
def is_in(val, items):
    
    if isinstance(items, basestring):
        items = items.split('|')
    return val in items
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;
    }
768680
public function isUploadArray($value) {
		if (!is_array($value)) {
			return false;
		}
		$requiredKeys = ['name', 'type', 'tmp_name', 'error', 'size'];
		$keys = array_keys($value);
		foreach ($requiredKeys as $key) {
			if (!in_array($key, $keys)) {
				return false;
			}
		}

		return true;
	}
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;
    }
591058
def _contains_array(self, val):
        """"""
        arr = self(arr_name=val.psy.arr_name)[0]
        is_not_list = any(
            map(lambda a: not isinstance(a, InteractiveList),
                [arr, val]))
        is_list = any(map(lambda a: isinstance(a, InteractiveList),
                          [arr, val]))
        # if one is an InteractiveList and the other not, they differ
        if is_list and is_not_list:
            return False
        # if both are interactive lists, check the lists
        if is_list:
            return all(a in arr for a in val) and all(a in val for a in arr)
        # else we check the shapes and values
        return arr is val
505780
private function check($value) {

		$values = ['yes', 'on', '1', 'true'];
		
		if(true === is_string($value)) {
			return true === in_array($value, $values);
		}

		return false;
	}