วิธีการลบค่าที่ซ้ำกันออกจากอาร์เรย์หลายมิติใน PHP

ฉันจะลบค่าที่ซ้ำกันออกจากอาร์เรย์หลายมิติใน PHP ได้อย่างไร

อาร์เรย์ตัวอย่าง:

Array
(
    [0] => Array
    (
        [0] => abc
        [1] => def
    )

    [1] => Array
    (
        [0] => ghi
        [1] => jkl
    )

    [2] => Array
    (
        [0] => mno
        [1] => pql
    )

    [3] => Array
    (
        [0] => abc
        [1] => def
    )

    [4] => Array
    (
        [0] => ghi
        [1] => jkl
    )

    [5] => Array
    (
        [0] => mno
        [1] => pql
    )

)

นี่คือวิธีอื่น ไม่มีการบันทึกตัวแปรกลาง

เราใช้สิ่งนี้เพื่อแยกผลลัพธ์ที่ซ้ำกันจากการสืบค้นที่ซ้อนกันหลายแบบ

$input = array_map("unserialize", array_unique(array_map("serialize", $input)));

ตั้งแต่ 5.2.9 คุณสามารถใช้array_unique()หากคุณใช้งานSORT_REGULARธงดังนี้:

array_unique($array, SORT_REGULAR);

สิ่งนี้ทำให้ฟังก์ชั่นเปรียบเทียบองค์ประกอบเพื่อความเท่าเทียมราวกับ$a == $bกำลังถูกใช้ซึ่งเหมาะสำหรับกรณีของคุณ

เอาท์พุต

Array
(
    [0] => Array
        (
            [0] => abc
            [1] => def
        )

    [1] => Array
        (
            [0] => ghi
            [1] => jkl
        )

    [2] => Array
        (
            [0] => mno
            [1] => pql
        )

)

อย่างไรก็ตามโปรดทราบว่าเอกสารระบุว่า:

array_unique() ไม่ได้มีวัตถุประสงค์เพื่อทำงานในอาร์เรย์หลายมิติ

ฉันมีปัญหาที่คล้ายกัน แต่ฉันพบวิธีแก้ปัญหาการทำงาน 100%

<?php
    function super_unique($array,$key)
    {
       $temp_array = [];
       foreach ($array as &$v) {
           if (!isset($temp_array[$v[$key]]))
           $temp_array[$v[$key]] =& $v;
       }
       $array = array_values($temp_array);
       return $array;

    }


$arr="";
$arr[0]['id']=0;
$arr[0]['titel']="ABC";
$arr[1]['id']=1;
$arr[1]['titel']="DEF";
$arr[2]['id']=2;
$arr[2]['titel']="ABC";
$arr[3]['id']=3;
$arr[3]['titel']="XYZ";

echo "<pre>";
print_r($arr);
echo "unique*********************<br/>";
print_r(super_unique($arr,'titel'));

?>

อีกวิธีหนึ่ง จะเก็บกุญแจไว้เช่นกัน

function array_unique_multidimensional($input)
{
    $serialized = array_map('serialize', $input);
    $unique = array_unique($serialized);
    return array_intersect_key($input, $unique);
}

ความคิดเห็นของผู้ใช้ในเอกสารarray_unique ()มีวิธีแก้ไขปัญหามากมาย นี่คือหนึ่งในนั้น:

kenrbnsn ที่ rbnsn dot com
27-Sep-2005 12:09

อีกหนึ่ง Array_Unique สำหรับอาร์เรย์ที่มีหลายระดับ ฉันได้ทดสอบสิ่งนี้กับอาร์เรย์สอง demensioned แล้วเท่านั้น แต่มันอาจจะทำให้เป็นแบบทั่วไปมากขึ้นหรือใช้การเรียกซ้ำ

ฟังก์ชันนี้ใช้ฟังก์ชัน serialize, array_unique และ unserialize เพื่อทำงาน

function multi_unique($array) {
    foreach ($array as $k=>$na)
        $new[$k] = serialize($na);
    $uniq = array_unique($new);
    foreach($uniq as $k=>$ser)
        $new1[$k] = unserialize($ser);
    return ($new1);
}

นี้เป็นจากhttp://ca3.php.net/manual/en/function.array-unique.php#57202

หาก "ลบรายการที่ซ้ำกัน" หมายถึง "ลบรายการที่ซ้ำกัน แต่ให้มีรายการนั้น" วิธีแก้ไขอาจใช้array_unique(...)กับ "คอลัมน์ตัวระบุ" ก่อนแล้วจึงลบคีย์ทั้งหมดในอาร์เรย์เดิมที่ถูกลบออกจากอาร์เรย์คอลัมน์ :

$array = [
    [
        'id' => '123',
        'foo' => 'aaa',
        'bar' => 'bbb'
    ],
    [
        'id' => '123',
        'foo' => 'ccc',
        'bar' => 'ddd'
    ],
    [
        'id' => '567',
        'foo' => 'eee',
        'bar' => 'fff'
    ]
];

$ids = array_column($array, 'id');
$ids = array_unique($ids);
$array = array_filter($array, function ($key, $value) use ($ids) {
    return in_array($value, array_keys($ids));
}, ARRAY_FILTER_USE_BOTH);

ผลลัพธ์คือ:

Array
(
    [0] => Array
        (
            [id] => 123
            [foo] => aaa
            [bar] => bbb
        )

    [2] => Array
        (
            [id] => 567
            [foo] => eee
            [bar] => fff
        )

)

Array
(
    [0] => Array
        (
            [id] => 1
            [name] => john
        )

    [1] => Array
        (
            [id] => 2
            [name] => smith
        )

    [2] => Array
        (
            [id] => 3
            [name] => john
        )

    [3] => Array
        (
            [id] => 4
            [name] => robert
        )

)

$temp = array_unique(array_column($array, 'name'));
$unique_arr = array_intersect_key($array, $temp);

นี่จะเป็นการลบชื่อที่ซ้ำกันออกจากอาร์เรย์ โดดเด่นด้วยกุญแจ

วิธีแก้ปัญหาง่าย ๆ :

array_unique($array, SORT_REGULAR)

เพียงใช้ตัวเลือก SORT_REGULAR เป็นพารามิเตอร์ตัวที่สอง

$uniqueArray = array_unique($array, SORT_REGULAR);

หากคุณต้องการกำจัดรายการที่ซ้ำกันบนคีย์เฉพาะเช่นรหัส mysqli นี่คือ funciton ที่เรียบง่าย

function search_array_compact($data,$key){
    $compact = [];
    foreach($data as $row){
        if(!in_array($row[$key],$compact)){
            $compact[] = $row;
        }
    }
    return $compact;
}

คะแนนโบนัส คุณสามารถผ่านอาร์เรย์ของคีย์และเพิ่มด้านหน้าด้านนอก แต่จะช้าลง 2 เท่าต่อคีย์เพิ่มเติม

วิธีที่ง่ายและตรรกะในการที่ไม่เหมือนใครอาเรย์หลายมิติมีดังต่อไปนี้

หากคุณมีอาร์เรย์เช่นนี้:

Array
(
    [Key1] => Array
        (
            [0] => Value1
            [1] => Value2
            [2] => Value1
            [3] => Value3
            [4] => Value1
        )
    [Key2] => Array
        (
            [0] => Value1
            [1] => Value2
            [2] => Value1
            [3] => Value3
            [4] => Value4
        )
)

ใช้foreachเพื่อแก้ปัญหานี้:

foreach($array as $k=>$v){
    $unique=array_unique($v);
    $array[$k]=$unique;
}

มันจะให้ผลลัพธ์ดังต่อไปนี้:

Array
(
    [Key1] => Array
        (
            [0] => Value1
            [1] => Value2
            [3] => Value3
        )
    [Key2] => Array
        (
            [0] => Value1
            [1] => Value2
            [3] => Value3
            [4] => Value4
        )
)

และถ้าคุณต้องการจัดลำดับของคีย์ใหม่

foreach($array as $k=>$v){
    $unique= array_values(array_unique($v));
    $array[$k]=$unique;
}

การดำเนินการนี้จะทำให้คุณได้รับการจัดเรียงค่าคีย์ดังนี้:

Array
(
    [Key1] => Array
        (
            [0] => Value1
            [1] => Value2
            [2] => Value3
        )
    [Key2] => Array
        (
            [0] => Value1
            [1] => Value2
            [2] => Value3
            [3] => Value4
        )
)

ฉันหวังว่านี่จะล้างทุกอย่าง

หากคุณมีอาร์เรย์ดังนี้:

(ผู้ใช้คือชื่อของอาร์เรย์)

Array=>
 [0] => (array)
   'user' => 'john'
   'age' => '23'
 [1] => (array)
  'user' => 'jane'
  'age' => '20'
 [2]=> (array)
  'user' => 'john'
  'age' => '23'

และคุณต้องการลบข้อมูลซ้ำ ... จากนั้น:

$serialized = array();
for ($i=0; $i < sizeof($users); $i++) { 
  $test = in_array($users['user'], $serialized);
    if ($test == false) {
      $serialized[] = $users['user'];
    }
 }

สามารถเป็นทางออกได้: หน้า

โซลูชันที่อ่านง่ายอาจไม่ใช่วิธีที่มีประสิทธิภาพที่สุด:

function arrayUnique($myArray){
    if(!is_array($myArray))
        return $myArray;

    foreach ($myArray as &$myvalue){
        $myvalue=serialize($myvalue);
    }

    $myArray=array_unique($myArray);

    foreach ($myArray as &$myvalue){
        $myvalue=unserialize($myvalue);
    }

    return $myArray;

} 

ในขณะที่ผู้คนกำลังพูดarray_unique()ช้ามากนี่คือตัวอย่างที่ฉันใช้สำหรับอาร์เรย์หลายมิติในระดับหนึ่ง

$serialized_array = array_map("serialize", $input);

foreach ($serialized_array as $key => $val) {
     $result[$val] = true;
}

$output = array_map("unserialize", (array_keys($result)));

การอ้างอิงผู้ใช้ครั้งแรกมีส่วนร่วมทราบarray_unique() หน้าฟังก์ชั่นใน php.net

มีคนมากมายถามฉันถึงวิธีสร้างอาร์เรย์หลายมิติที่ไม่ซ้ำใคร ฉันได้รับการอ้างอิงจากความคิดเห็นของคุณและมันช่วยฉันได้

ก่อนอื่นขอขอบคุณ @jeromegamez @Daveilers สำหรับวิธีแก้ปัญหาของคุณ แต่ทุกครั้งที่ฉันให้คำตอบพวกเขาถามฉันว่า 'serialize' และ 'unserialize' นี้ทำงานอย่างไร นั่นเป็นเหตุผลที่ฉันต้องการแบ่งปันเหตุผลนี้กับคุณเพื่อที่จะช่วยให้ผู้คนจำนวนมากเข้าใจแนวคิดที่อยู่เบื้องหลัง

ฉันกำลังอธิบายว่าเพราะเหตุใดเราจึงใช้ 'ทำให้เป็นอันดับ' และ 'ไม่ระบุ' ในขั้นตอน:

ขั้นตอนที่ 1: แปลงอาเรย์หลายมิติเป็นอาเรย์หนึ่งมิติ

ในการแปลงอาร์เรย์หลายมิติให้เป็นอาร์เรย์หนึ่งมิติขั้นแรกให้สร้างการแทนค่าสตรีมไบต์ขององค์ประกอบทั้งหมด (รวมถึงอาร์เรย์ที่ซ้อนกัน) ภายในอาร์เรย์ ฟังก์ชั่นเป็นอันดับ () สามารถสร้างการเป็นตัวแทนไบต์ของค่า ในการสร้างการเป็นตัวแทนไบต์ขององค์ประกอบทั้งหมดให้เรียกฟังก์ชั่นอนุกรม () ภายในฟังก์ชั่น array_map () เป็นฟังก์ชั่นการโทรกลับ ผลลัพธ์จะเป็นอาร์เรย์หนึ่งมิติไม่ว่าจะมีอาร์เรย์หลายมิติหลายระดับ

ขั้นตอนที่ 2: ทำให้ค่าไม่ซ้ำกัน

เพื่อทำให้อาเรย์หนึ่งมิติมีความเป็นเอกลักษณ์ให้ใช้ฟังก์ชัน array_unique ()

ขั้นตอนที่ 3: แปลงกลับเป็นอาร์เรย์หลายมิติ

แม้ว่าตอนนี้อาร์เรย์จะมีค่าไม่ซ้ำกัน แต่ค่าดูเหมือนเป็นตัวแทนไบต์ ในการแปลงกลับเป็นอาเรย์หลายมิติให้ใช้ฟังก์ชัน unserialize ()

$input = array_map("unserialize", array_unique(array_map("serialize", $input)));

ขอบคุณอีกครั้งสำหรับทั้งหมดนี้

ทางเลือกในการทำให้เป็นอันดับและไม่ซ้ำกัน

$test = [
    ['abc','def'],
    ['ghi','jkl'],
    ['mno','pql'],
    ['abc','def'],
    ['ghi','jkl'],
    ['mno','pql'],
];

$result = array_reduce(
    $test,
    function($carry,$item){
        if(!in_array($item,$carry)) {
            array_push($carry,$item);
        }
        return $carry;
    },
    []
);

var_dump($result);

/*
 php unique.php
array(3) {
    [0] =>
        array(2) {
            [0] =>
                string(3) "abc"
            [1] =>
                string(3) "def"
        }
    [1] =>
        array(2) {
            [0] =>
                string(3) "ghi"
            [1] =>
                string(3) "jkl"
        }
    [2] =>
        array(2) {
              [0] =>
                  string(3) "mno"
              [1] =>
                  string(3) "pql"
        }
}

* /

หากคุณมีอาร์เรย์เช่นนี้

data = array
(
[0] => array
(
    [subject] => a
    [object] => c
),
[1] => array
(
    [subject] => b
    [object] => d
),
[2] => array
(
    [subject] => d
    [object] => b
),
[3] => array
(
    [subject] => d
    [object] => c
),
[4] => array
(
    [subject] => c
    [object] => a
),
[5] => array
(
    [subject] => c
    [object] => d
)
)

และคุณต้องการได้รับอาร์เรย์ดังนี้:

data = array
(
[0] => array
(
    [subject] => a
    [object] => c
),
[1] => array
(
    [subject] => b
    [object] => d
),
[2] => array
(
    [subject] => d
    [object] => c
)
)

หรือ

data = array
(
[0] => array
(
    [subject] => d
    [object] => b
),
[1] => array
(
    [subject] => c
    [object] => a
),
[2] => array
(
    [subject] => c
    [object] => d
)
)

รหัสต่อไปนี้สามารถช่วยได้

    $data1 = array();
    $data1 = $data;
    for($q=0;$q<count($data);$q++)
    {
            for($p=0;$p<count($data1);$p++)
            {
                    if (($data[$q]["subject"] == $data1[$p]["object"]) && ($data[$q]["object"] == $data1[$p]["subject"]))
                    {
                            $data1[$p]["subject"] = $data[$q]["subject"];
                            $data1[$p]["object"] = $data[$q]["object"];
                    }
            }
    }
    $data1 = array_values(array_map("unserialize", array_unique(array_map("serialize", $data1))));
    $data = $data1;

ฉันได้รับปัญหานี้อย่างมากและได้พิจารณาแล้วว่าทางออกที่ดีที่สุดควรเป็นไปตามกฎสองข้อ

1. เพื่อความยืดหยุ่นให้ปรับเปลี่ยนอาร์เรย์ในตำแหน่ง ไม่มีการคัดลอกไปยังอาร์เรย์ใหม่
2. สำหรับประสิทธิภาพการเปรียบเทียบแต่ละครั้งควรทำเพียงครั้งเดียว

เมื่อคำนึงถึงสิ่งนี้และได้รับประโยชน์ทั้งหมดของ PHP ด้านล่างเป็นวิธีแก้ปัญหาที่ฉันคิดขึ้นมา ต่างจากคำตอบอื่น ๆ บางคำ แต่มีความสามารถในการลบองค์ประกอบตามคีย์ที่คุณต้องการ คาดว่าอาร์เรย์อินพุตจะเป็นคีย์ตัวเลข

$count_array = count($input);
for ($i = 0; $i < $count_array; $i++) {
    if (isset($input[$i])) {
        for ($j = $i+1; $j < $count_array; $j++) {
            if (isset($input[$j])) {
                //this is where you do your comparison for dupes
                if ($input[$i]['checksum'] == $input[$j]['checksum']) {
                    unset($input[$j]);
                }
            }
        }
    }
}

ข้อเสียเปรียบเพียงอย่างเดียวคือกุญแจไม่ได้อยู่ในลำดับเมื่อการวนซ้ำเสร็จสมบูรณ์ นี่ไม่ใช่ปัญหาหากคุณใช้ลูป foreach ในแต่ละครั้ง แต่ถ้าคุณจำเป็นต้องใช้ลูป for for loop คุณสามารถใส่$input = array_values($input);เครื่องหมายด้านบนเพื่อกำหนดหมายเลขใหม่

จากคำตอบที่ทำเครื่องหมายว่าถูกต้องให้เพิ่มคำตอบของฉัน มีการเพิ่มโค้ดขนาดเล็กเพื่อรีเซ็ตดัชนี -

$input = array_values(array_map("unserialize", array_unique(array_map("serialize", $inputArray))));