Cách xóa các giá trị trùng lặp khỏi một mảng trong PHP

Làm cách nào để xóa các giá trị trùng lặp khỏi một mảng trong PHP?

Sử dụng mảng_unique () .

Thí dụ:

$array = array(1, 2, 2, 3);
$array = array_unique($array); // Array is now (1, 2, 3)

Sử dụng array_values(array_unique($array));

array_unique: cho mảng duy nhất array_values: cho reindexing

//Find duplicates 

$arr = array( 
    'unique', 
    'duplicate', 
    'distinct', 
    'justone', 
    'three3', 
    'duplicate', 
    'three3', 
    'three3', 
    'onlyone' 
);

$unique = array_unique($arr); 
$dupes = array_diff_key( $arr, $unique ); 
    // array( 5=>'duplicate', 6=>'three3' 7=>'three3' )

// count duplicates

array_count_values($dupes); // array( 'duplicate'=>1, 'three3'=>2 )

Điều duy nhất làm việc cho tôi là:

$array = array_unique($array, SORT_REGULAR);

Chỉnh sửa: SORT_REGULARgiữ nguyên thứ tự của mảng ban đầu.

$result = array();
foreach ($array as $key => $value){
  if(!in_array($value, $result))
    $result[$key]=$value;
}

đôi khi array_unique()không phải là cách, nếu bạn muốn nhận các mục độc đáo VÀ trùng lặp ...

$unique=array("","A1","","A2","","A1","");
$duplicated=array();

foreach($unique as $k=>$v) {

if( ($kt=array_search($v,$unique))!==false and $k!=$kt )
 { unset($unique[$kt]);  $duplicated[]=$v; }

}

sort($unique); // optional
sort($duplicated); // optional

kết quả trên

array ( 0 => '', 1 => 'A1', 2 => 'A2', ) /* $unique */

array ( 0 => '', 1 => '', 2 => '', 3 => 'A1', ) /* $duplicated */

Chúng tôi có thể tạo loại mảng như vậy để sử dụng giá trị cuối cùng này sẽ được cập nhật thành giá trị cột hoặc khóa và chúng tôi sẽ nhận được giá trị duy nhất từ ​​mảng ...

$array = array (1,3,4,2,1,7,4,9,7,5,9);
    $data=array();
    foreach($array as $value ){

        $data[$value]= $value;

    }

    array_keys($data);
    OR
    array_values($data);

explode(",", implode(",", array_unique(explode(",", $YOUR_ARRAY))));

Điều này sẽ chăm sóc các hiệp hội quan trọng và tuần tự hóa các khóa cho mảng mới kết quả :-)

Tùy thuộc vào kích thước của mảng của bạn, tôi đã tìm thấy

$array = array_values( array_flip( array_flip( $array ) ) );

có thể nhanh hơn mảng_unique.

Đó là một cách tuyệt vời để làm điều đó. Có thể muốn đảm bảo đầu ra của nó trở lại một mảng một lần nữa. Bây giờ bạn chỉ hiển thị giá trị duy nhất cuối cùng.

Thử cái này:

$arrDuplicate = array ("","",1,3,"",5);

foreach (array_unique($arrDuplicate) as $v){
  if($v != "") { $arrRemoved[] = $v; }
}
print_r ($arrRemoved);

    if (@!in_array($classified->category,$arr)){        
                                    $arr[] = $classified->category;
                                 ?>

            <?php } endwhile; wp_reset_query(); ?>

lần đầu tiên kiểm tra giá trị trong mảng và tìm thấy cùng một giá trị bỏ qua nó

Xóa các giá trị trùng lặp khỏi một mảng kết hợp trong PHP.

$arrDup = Array ('0' => 'aaa-aaa' , 'SKU' => 'aaa-aaa' , '1' => '12/1/1' , 'date' => '12/1/1' , '2' => '1.15' , 'cost' => '1.15' );

foreach($arrDup as $k =>  $v){
  if(!( isset ($hold[$v])))
      $hold[$v]=1;
  else
      unset($arrDup[$k]);
}

Mảng ([0] => aaa-aaa [1] => 12/1/1 [2] => 1.15)

Có thể có nhiều cách để làm những việc này, như sau

//first method
$filter = array_map("unserialize", array_unique(array_map("serialize", $arr)));

//second method
$array = array_unique($arr, SORT_REGULAR);

Nếu bạn quan tâm đến hiệu suất và có mảng đơn giản, hãy sử dụng:

array_keys(array_flip($array));

Nó nhanh hơn nhiều lần so với mảng_unique.

$a = array(1, 2, 3, 4); 
$b = array(1, 6, 5, 2, 9); 
$c = array_merge($a, $b);
$unique = array_keys(array_flip($c));
print_r($unique);

$arrDuplicate = array ("","",1,3,"",5);
 foreach(array_unique($arrDuplicate) as $v){
  if($v != "" ){$arrRemoved = $v;  }}
print_r($arrRemoved);

function arrayUnique($myArray)
{
    $newArray = Array();
    if (is_array($myArray))
    {
        foreach($myArray as $key=>$val)
        {
            if (is_array($val))
            {
                $val2 = arrayUnique($val);
            }
            else
            {
                $val2 = $val;
                $newArray=array_unique($myArray);
                $newArray=deleteEmpty($newArray);
                break;
            }
            if (!empty($val2))
            {
                $newArray[$key] = $val2;
            }
        }
    }
    return ($newArray);
}

function deleteEmpty($myArray)
{
    $retArray= Array();
    foreach($myArray as $key=>$val)
    {
        if (($key<>"") && ($val<>""))
        {
            $retArray[$key] = $val;
        }
    }
    return $retArray;
}

thử mã ngắn và ngọt ngào này -

$array = array (1,4,2,1,7,4,9,7,5,9);
$unique = array();

foreach($array as $v){
  isset($k[$v]) || ($k[$v]=1) && $unique[] = $v;
  }

var_dump($unique);

Đầu ra -

array(6) {
  [0]=>
  int(1)
  [1]=>
  int(4)
  [2]=>
  int(2)
  [3]=>
  int(7)
  [4]=>
  int(9)
  [5]=>
  int(5)
}

<?php
$arr1 = [1,1,2,3,4,5,6,3,1,3,5,3,20];    
print_r(arr_unique($arr1));


function arr_unique($arr) {
  sort($arr);
  $curr = $arr[0];
  $uni_arr[] = $arr[0];
  for($i=0; $i<count($arr);$i++){
      if($curr != $arr[$i]) {
        $uni_arr[] = $arr[$i];
        $curr = $arr[$i];
      }
  }
  return $uni_arr;
}

Ở đây tôi đã tạo ra một mảng trống thứ hai và forvòng lặp được sử dụng với mảng đầu tiên có các bản sao. Nó sẽ chạy nhiều lần như đếm số của mảng đầu tiên. Sau đó so sánh với vị trí của mảng với mảng đầu tiên và khớp với nó có mục này hay không bằng cách sử dụng in_array. Nếu không thì nó sẽ thêm mục đó vào mảng thứ hai array_push.

$a = array(1,2,3,1,3,4,5);
$count = count($a);
$b = [];
for($i=0; $i<$count; $i++){
    if(!in_array($a[$i], $b)){
        array_push($b, $a[$i]);
    }
}
print_r ($b);

Nó có thể được thực hiện thông qua chức năng Tôi tạo ba chức năng trùng lặp trả về các giá trị được nhân đôi trong mảng.

Hàm thứ hai chỉ trả về các giá trị có nghĩa là đơn không được lặp lại trong mảng và hàm thứ ba và hàm đầy đủ trả về tất cả các giá trị nhưng không bị trùng lặp nếu có bất kỳ giá trị nào được nhân đôi, nó chuyển đổi thành đơn;

function duplicate($arr) {
    $duplicate;
    $count = array_count_values($arr);
    foreach($arr as $key => $value) {
        if ($count[$value] > 1) {
            $duplicate[$value] = $value;
        }
    }
    return $duplicate;
}
function single($arr) {
    $single;
    $count = array_count_values($arr);
    foreach($arr as $key => $value) {
        if ($count[$value] == 1) {
            $single[$value] = $value;
        }
    }
    return $single;
}
function full($arr, $arry) {
    $full = $arr + $arry;
    sort($full);
    return $full;
}

$array = array("a" => "moon", "star", "b" => "moon", "star", "sky");

// Deleting the duplicate items
$result = array_unique($array);
print_r($result);

ref: Bản trình diễn

Một thay thế cho hàm Array_unique () ..

Sử dụng thuật toán lực Brute

// [1] Đây là mảng của chúng tôi với các mục trùng lặp

$ trận đấu = ["jorge", "melvin", "chelsy", "melvin", "jorge", "smith"];

// [2] Container cho mảng mới mà không có bất kỳ mục trùng lặp nào

$ mảng = [];

// [3] lấy chiều dài của mảng trùng lặp và đặt nó vào var len để sử dụng cho vòng lặp

$ len = đếm ($ khớp);

// [4] Nếu khớp với khóa mảng ($ i) Lặp lại vòng lặp hiện tại không có sẵn trong
// [4] mảng $ Array sau đó đẩy giá trị khóa lặp hiện tại của các kết quả khớp [$ i]
// [4] vào mảng mảng.

cho ($ i = 0; $ i

if(array_search($matches[$i], $arr) === false){

    array_push($arr,$matches[$i]);
}
}

//print the array $arr.
print_r($arr);

//Result: Array
(
[0] => jorge
[1] => melvin
[2] => chelsy
[3] => smith
)

Tôi đã làm điều này mà không sử dụng bất kỳ chức năng.

$arr = array("1", "2", "3", "4", "5", "4", "2", "1");

$len = count($arr);
for ($i = 0; $i < $len; $i++) {
  $temp = $arr[$i];
  $j = $i;
  for ($k = 0; $k < $len; $k++) {
    if ($k != $j) {
      if ($temp == $arr[$k]) {
        echo $temp."<br>";
        $arr[$k]=" ";
      }
    }
  }
}

for ($i = 0; $i < $len; $i++) {
  echo $arr[$i] . " <br><br>";
}