Php массив элемент равный

Проверьте, все ли значения в массиве одинаковы

Мне нужно проверить, все ли значения в массиве равны.

$allValues = array( 'true', 'true', 'true', ); 

Если каждое значение в массиве равно ‘true’ тогда я хочу повторить ‘all true’ , Если любое значение в массиве равно ‘false’ тогда я хочу повторить ‘some false’

Есть идеи о том, как я могу это сделать?

Решение

все значения равны тестовому значению

if (count(array_unique($allvalues)) === 1 && end($allvalues) === 'true')

или просто проверить на наличие того, что вы не хотите.

if (in_array('false', $allvalues, true))

Предпочитайте последний метод, если вы уверены, что в массиве может быть только 2 возможных значения, так как он намного эффективнее. Но если вы сомневаетесь, медленная программа лучше, чем неправильная, так что используйте первый метод.

Если вы не можете использовать второй метод, ваш массив очень большой, и содержимое массива скорее всего иметь более 1 значения (особенно если это значение может произойти ближе к началу массива), это может быть много быстрее сделать следующее:

function isHomogenous($arr) < $firstValue = current($arr); foreach ($arr as $val) < if ($firstValue !== $val) < return false; >> return true; > 

* примечание — некоторые ответы интерпретируют исходный вопрос как 1) how to check if all values are the same в то время как другие интерпретировали это как 2) how to check if all values are the same AND make sure that value equals the test value , Решение, которое вы выбираете, должно учитывать эту деталь. Мои первые 2 решения ответили # 1. мой isHomogenous() функция отвечает # 2, хотя вы можете изменить его, чтобы ответить # 1, передав значение $firstValue в качестве тестового значения, вместо использования первого значения, найденного в массиве, как я сделал.

Другие решения

Если в вашем массиве вместо строк содержатся действительные логические значения (или целые числа), вы можете использовать array_sum :

$allvalues = array(TRUE, TRUE, TRUE); if(array_sum($allvalues) == count($allvalues)) < echo 'all true'; >else

Это работает, потому что TRUE будет оцениваться как 1 , а также FALSE как 0 ,

Кроме того, вы можете сжать ответ козла, если он не двоичный:

if (count(array_unique($allvalues)) === 1 && end($allvalues) === 'true') < // . >

if (array_unique($allvalues) === array('foobar')) < // all values in array are "foobar">

Почему бы просто не сравнить счет после звонка array_unique() ?

Чтобы проверить, все ли элементы в массиве одинаковы, должно быть так же просто, как:

$allValuesAreTheSame = (count(array_unique($allvalues)) === 1); 

Это должно работать независимо от типа значений в массиве.

Вы можете сравнить мин и макс … не самый быстрый способ; р

$homogenous = ( min($array) === max($array) ); 

$alltrue = 1; foreach($array as $item) < if($item!='true') < $alltrue = 0; >> if($alltrue) < echo("all true."); >else

Технически это не проверяет «некоторые ложные», это проверяет «не все верно». Но, похоже, вы уверены, что единственные значения, которые вы получите, это «true» и «false».

same(array(true, true, true)); // => true 

$x = 0; foreach ($allvalues as $a) < if ($a != $checkvalue) < $x = 1; >> //then check against $x if ($x != 0) < //not all values are the same >

Источник

Php массив элемент равный

The + operator returns the right-hand array appended to the left-hand array; for keys that exist in both arrays, the elements from the left-hand array will be used, and the matching elements from the right-hand array will be ignored.

$a = array( «a» => «apple» , «b» => «banana» );
$b = array( «a» => «pear» , «b» => «strawberry» , «c» => «cherry» );

$c = $a + $b ; // Union of $a and $b
echo «Union of \$a and \$b: \n» ;
var_dump ( $c );

$c = $b + $a ; // Union of $b and $a
echo «Union of \$b and \$a: \n» ;
var_dump ( $c );

$a += $b ; // Union of $a += $b is $a and $b
echo «Union of \$a += \$b: \n» ;
var_dump ( $a );
?>

Union of $a and $b: array(3) < ["a"]=>string(5) "apple" ["b"]=> string(6) "banana" ["c"]=> string(6) "cherry" > Union of $b and $a: array(3) < ["a"]=>string(4) "pear" ["b"]=> string(10) "strawberry" ["c"]=> string(6) "cherry" > Union of $a += $b: array(3) < ["a"]=>string(5) "apple" ["b"]=> string(6) "banana" ["c"]=> string(6) "cherry" >

Elements of arrays are equal for the comparison if they have the same key and value.

Example #1 Comparing arrays

$a = array( «apple» , «banana» );
$b = array( 1 => «banana» , «0» => «apple» );

var_dump ( $a == $b ); // bool(true)
var_dump ( $a === $b ); // bool(false)
?>

See Also

User Contributed Notes 14 notes

The union operator did not behave as I thought it would on first glance. It implements a union (of sorts) based on the keys of the array, not on the values.

For instance:
$a = array( ‘one’ , ‘two’ );
$b =array( ‘three’ , ‘four’ , ‘five’ );

//not a union of arrays’ values
echo ‘$a + $b : ‘ ;
print_r ( $a + $b );

//a union of arrays’ values
echo «array_unique(array_merge( $a , $b )):» ;
// cribbed from http://oreilly.com/catalog/progphp/chapter/ch05.html
print_r ( array_unique ( array_merge ( $a , $b )));
?>

//output

$a + $b : Array
(
[0] => one
[1] => two
[2] => five
)
array_unique(array_merge(Array,Array)):Array
(
[0] => one
[1] => two
[2] => three
[3] => four
[4] => five
)

The example may get u into thinking that the identical operator returns true because the key of apple is a string but that is not the case, cause if a string array key is the standart representation of a integer it’s gets a numeral key automaticly.

The identical operator just requires that the keys are in the same order in both arrays:

$a = array ( 0 => «apple» , 1 => «banana» );
$b = array ( 1 => «banana» , 0 => «apple» );

var_dump ( $a === $b ); // prints bool(false) as well

$b = array ( «0» => «apple» , «1» => «banana» );

var_dump ( $a === $b ); // prints bool(true)
?>

Note that + will not renumber numeric array keys. If you have two numeric arrays, and their indices overlap, + will use the first array’s values for each numeric key, adding the 2nd array’s values only where the first doesn’t already have a value for that index. Example:

$a = array(‘red’, ‘orange’);
$b = array(‘yellow’, ‘green’, ‘blue’);
$both = $a + $b;
var_dump($both);

array(3) < [0]=>string(3) «red» [1]=> string(6) «orange» [2]=> string(4) «blue» >

To get a 5-element array, use array_merge.

It should be mentioned that the array union operator functions almost identically to array_replace with the exception that precedence of arguments is reversed.

The reason for the above output is that EVERY array in PHP is an associative one.
Since the 3 elements in $b have the same keys( or numeric indices ) as those in $a, those elements in $b are ignored by the union operator.

[]= could be considered an Array Operator (in the same way that .= is a String Operator).
[]= pushes an element onto the end of an array, similar to array_push:
$array= array(0=>»Amir»,1=>»needs»);
$array[]= «job»;
print_r($array);
?>
Prints: Array ( [0] => Amir [1] => needs [2] => job )

The note about array comparison by Q1712 is not entirely accurate.

«The identical operator just requires that the keys are in the same order in both arrays:»

This may have been the case in past (I cannot verify it). It requires that the keys are in the same order AND that the values match

$a = array ( 0 => «apple» , 1 => «banana» );
$b = array ( 1 => «banana» , 0 => «apple» );

var_dump ( $a === $b ); // prints bool(false) as well

$b = array ( «0» => «apple» , «1» => «banana» );

var_dump ( $a === $b ); // prints bool(true)

$b = array ( «0» => «apple-1» , «1» => «banana-1» );

var_dump ( $a === $b ); // prints bool(false)

Merge two arrays and retain only unique values.
Append values from second array.
Do not care about keys.

$array2 = [
0 => ‘melon’ ,
1 => ‘orange’ ,
2 => ‘banana’ ,
];

$result = array_keys (
array_flip ( $array1 ) + array_flip ( $array2 )
);
?>

Result:
[
[0] => «apple»,
[1] => «orange»,
[2] => «pear»,
[3] => «melon»,
[4] => «banana»,
>

Simple array arithmetic:
A more compact way of adding or subtracting the elements at identical keys.

function array_add ( $a1 , $a2 ) < // .
// adds the values at identical keys together
$aRes = $a1 ;
foreach ( array_slice ( func_get_args (), 1 ) as $aRay ) foreach ( array_intersect_key ( $aRay , $aRes ) as $key => $val ) $aRes [ $key ] += $val ;
$aRes += $aRay ; >
return $aRes ; >

function array_subtract ( $a1 , $a2 ) < // .
// adds the values at identical keys together
$aRes = $a1 ;
foreach ( array_slice ( func_get_args (), 1 ) as $aRay ) foreach ( array_intersect_key ( $aRay , $aRes ) as $key => $val ) $aRes [ $key ] -= $val ;
foreach ( array_diff_key ( $aRay , $aRes ) as $key => $val ) $aRes [ $key ] = — $val ; >
return $aRes ; >

Example :
$a1 = array( 9 , 8 , 7 );
$a2 = array( 1 => 7 , 6 , 5 );
$a3 = array( 2 => 5 , 4 , 3 );

$aSum = array_add ( $a1 , $a2 , $a3 );
$aDiff = array_subtract ( $a1 , $a2 , $a3 );

// $aSum => [9, 15, 18, 9, 3]// $aDiff => [9, 1, -4, -9, -3]
?>

To make a similar function, array_concatenate(), change only the first of the two ‘+=’ in array_add() to ‘.=’
Csaba Gabor from Vienna

When comparing arrays that have (some or all) element-values that are themselves array, then in PHP5 it seems that == and === are applied recursively — that is
* two arrays satisfy == if they have the same keys, and the values at each key satisfy == for whatever they happen to be (which might be arrays);
* two arrays satisfy === if they have the same keys, and the values at each key satisfy === for whatever (etc.).

Which explains what happens if we compare two arrays of arrays of arrays of.

Likewise, the corresponding inversions for != <> and !==.

I’ve tested this to array-of-array-of-array, which seems fairly convincing. I’ve not tried it in PHP4 or earlier.

Look out use + with array combine.

$arr = array(1, 2, 3);
$int=345;
$arr=$arr+$int;

Of couse,use + to combine array is easy and readable.
But if one of the variable is not array type(like above code) ,that would make a PHP Fatal Error:
PHP Fatal error: Unsupported operand types
Maybe should do check before.

hi just see one more example of union.

$a = array( 1 , 2 , 3 );
$b = array( 1 , 7 , 8 , 9 , 10 );
$c = $a + $b ; // Union of $a and $b
echo «Union of \$a and \$b: \n» ;
//echo $c
print_r ( $c );
?>
//output
Union of $a and $b: Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 9 [4] => 10 )

«The + operator appends the right elements in the array from left, whereas duplicated keys are NOT overwritten»

$a = array(«a» => ‘A’, «b» => ‘B’);
$b = array(«a» => ‘A’, «b» => ‘B’, «c» => ‘C’);

$c = $a + $b // or $b + a is the same output;

//Output for $a + b or $b + a
Array (
[a] => A
[b] => B
[c] => C
)

• Operators
  • Operator Precedence
  • Arithmetic Operators
  • Assignment Operators
  • Bitwise Operators
  • Comparison Operators
  • Error Control Operators
  • Execution Operators
  • Incrementing/Decrementing Operators
  • Logical Operators
  • String Operators
  • Array Operators
  • Type Operators

  Источник

  Проверьте, равны ли значения двух массивов в PHP

  Считаете ли вы этот сниппет полезным? То поделитесь этим с друзьями или коллегами. Это поможет нам сделать наши бесплатные веб-инструменты лучше.

  1) Сравнение массивов с использованием строгого равенства (===)

  Два массива строго равны ( $a === $b ), когда:

  • у них одинаковые пары ключ/значение
  • пары ключ/значение находятся в том же порядке
  • все значения одного типа

  2) Сравнение массивов с использованием свободного равенства (==)

  Два массива «слабо» равны ( $a == $b ) когда у них одинаковые пары ключ/значение

  Примеры сравнения 1 и 2 массивов

  Массивы, имеющие одинаковые пары ключ/значение в одном порядке и со значениями одного типа:

   'a', 1 => 'b']; var_dump($a == $b); // true var_dump($a === $b); // true

   'bar' ]]; $b = ['a', 'b', [ 'foo' => 'bar' ]]; var_dump($a == $b); // true var_dump($a === $b); // true $a = ['a', 'b', [ 'foo' => 'bar' ]]; $b = [0 => 'a', 1 => 'b', 3 => [ 'foo' => 'bar' ]]; var_dump($a == $b); // true var_dump($a === $b); // true

  Массивы, имеющие одинаковые пары ключ/значение в одном порядке, но с разными типами ключей:

   'a', 1 => 'b', 2 => 'c']; $b = [false => 'a', true => 'b', '2' => 'c']; var_dump($a == $b); // true var_dump($a === $b); // true

  Массивы, у которых разные пары ключ/значение:

   'a', 1 => 'b']; $b = [0 => 'b', 1 => 'a']; var_dump($a == $b); // false var_dump($a === $b); // false

   'a', 2 => 'b', [ 'foo' => 'bar' ]]; $b = [[ 'foo' => 'bar' ], 2 => 'b', 1 => 'a']; var_dump($a == $b); // false var_dump($a === $b); // false $a = [1 => 'a', 2 => 'b', 3 => [ 'foo' => 'bar' ]]; $b = [0 => [ 'foo' => 'bar' ], 2 => 'b', 1 => 'a']; var_dump($a == $b); // false var_dump($a === $b); // false

  Значения массивов разного типа:

   'a', 2 => 'b']; $b = [2 => 'b', 1 => 'a']; var_dump($a == $b); // true var_dump($a === $b); // false

  Но с индексированными массивами это не будет работать должным образом

   'a', 1 => 'b']; $b = [0 => 'b', 1 => 'a']; var_dump($a == $b); // false var_dump($a === $b); // false

  Чтобы решить эту проблему, используйте:

   $a = [0 => 'a', 1 => 'b']; $b = [0 => 'b', 1 => 'a']; var_dump(arrayEqual($a, $b)); // true

  Источник