التنفيذ على المصفوفات والتعامل معها في PHP – PHP

تطبيق دالة على كل عنصر من عناصر المصفوفة

نستخدم الدالة array_map()‎ لتطبيق دالة على جميع عناصر مصفوفة ما، وتُرجع لنا مصفوفة جديدة:

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

// يتم المرور على كل عنصر من عناصر المصفوفة ويُخزَّن في معامل الدالة
$newArray = array_map(function($item) {
    return $item + 1;
}, $array);

// array(2,3,4,5,6) الآن $newArray قيمة

يمكنك استخدام دالة ذات اسم بدلًا من استخدام دالة مجهولة الاسم، فنكتب الشيفرة السابقة كالتالي:

function addOne($item) {
    return $item + 1;
}

$array = array(1, 2, 3, 4, 5);
$newArray = array_map('addOne', $array);

إذا كانت الدالة المسمّاة هي تابع صنف فيجب تضمين مرجع إلى كائن الصنف الذي يعود التابع له عند استدعاء الدالة:

class Example {
    public function addOne($item) {
        return $item + 1;
    }

    public function doCalculation() {
        $array = array(1, 2, 3, 4, 5);
        $newArray = array_map(array($this, 'addOne'), $array);
    }
}

الطريقة الثانية لتطبيق دالة على عناصر المصفوفة هي استخدام الدالة array_walk()‎ والدالة array_walk_recursive()‎، يُمرَّر رد النداء (callback) إلى هاتين الدالتين ويأخذ مفتاح/فهرس وقيمة كل عنصر من عناصر المصفوفة، لا ترجع هذه الدوال دوالًا جديدة إنّما تُرجع قيمة منطقية تدل على نجاح تنفيذ الدالة، يمكننا مثلًا طباعة كل عنصر في المصفوفة بكتابة الشيفرة التالية:

$array = array(1, 2, 3, 4, 5);
array_walk($array, function($value, $key) {
    echo $value . ' ';
});
// "1 2 3 4 5"

يمكن تمرير قيمة معامل رد النداء بالمرجعية مما يسمح لك بتمرير القيمة مباشرةً في المصفوفة الأصلية:

$array = array(1, 2, 3, 4, 5);
array_walk($array, function(&$value, $key) {
    $value++;
});

// array(2,3,4,5,6) الآن $array قيمة

نستخدم الدالة array_walk_recursive()‎ مع المصفوفات المتداخلة (nested) للتعامل مع كل مصفوفة فرعية:

$array = array(1, array(2, 3, array(4, 5), 6);
array_walk_recursive($array, function($value, $key) {
    echo $value . ' ';
});

// "1 2 3 4 5 6"

لاحظ أنّ الدالتين array_walk()‎ وarray_walk_recursive()‎ يسمحان لك بتغيير قيمة عناصر المصفوفة وليس المفاتيح، كما أنّه يمكنك تمرير المفاتيح بالمرجع في رد النداء لكن هذا ليس له تأثير.

تقسيم المصفوفة إلى أجزاء (chunks)

تقسّم الدالة array_chunk()‎ المصفوفة إلى أجزاء صغيرة.

بفرض لدينا الدالة أحادية البعد التالية:

$input_array = array('a', 'b', 'c', 'd', 'e');

وطبّقنا الدالة array_chunk()‎ عليها:

$output_array = array_chunk($input_array, 2);

تقسّم الشيفرة السابقة المصفوفة إلى مصفوفات أصغر تحتوي كلّ منها عنصرين وتنشئ مصفوفة جديدة متعددة الأبعاد:

Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
        )
    [1] => Array
        (
            [0] => c
            [1] => d
        )
    [2] => Array
        (
            [0] => e
        )
)

إذا لم يكن من الممكن تقسيم عناصر المصفوفة بالتساوي وفقًا للحجم المحدد فإنّ المصفوفة الأخيرة ستحمل العناصر الباقية وتكون أصغر من باقي المصفوفات.

إذا مررنا للوسيط الثاني عددًا أصغر من 1 سيُرمى E_WARNING وستكون مصفوفة الخرج NULL.

المعامل تفاصيل
$array (array) مصفوفة الدخل التي نريد العمل عليها
$size (int) حجم المصفوفة الصغيرة (عدد صحيح)‏
$preserve_keys (boolean) (اختياري) FALSE وإلا TRUE إذا أردت أن تحافظ المصفوفات الصغيرة على المفاتيح تكون قيمته

تجميع عناصر مصفوفة لتشكيل سلسلة نصية

تجمع الدالة implode()‎ كل قيم المصفوفة لكنها تفقد معلومات المفاتيح:

$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];

echo implode(" ", $arr); 

// AA BB CC

نستطيع تجميع المفاتيح باستدعاء الدالة array_keys()‎:

$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];

echo implode(" ", array_keys($arr)); 

// a b c

يعدّ تجميع القيم مع المفاتيح أكثر تعقيدًا لكن يمكن القيام به بنمط الدالة:

$arr = ['a' => "AA", 'b' => "BB", 'c' => "CC"];
echo implode(" ", array_map(function($key, $val) {
    // دالة تربط المفتاح بالقيمة
    return "$key:$val"; 
}, array_keys($arr), $arr));

// a:AA b:BB c:CC

تفكيك مصفوفة باستخدام list()‎

يمكن استخدام الدالة list()‎ لإسناد قائمة من قيم المتغيرات إلى مصفوفة. كما يمكنك الاطلاع على الدالة compact()‎.

// بمفاتيح مرقمة تبدأ من الصفر $array إلى عناصر المصفوفة $a,$b,$c إسناد قيم المتغيرات
list($a, $b, $c) = $array;

بدءًا من الإصدار 7.1 يمكنك استخدام الصيغة المختصرة:

// بمفاتيح مرقمة تبدأ من الصفر $array إلى عناصر المصفوفة $a,$b,$c إسناد قيم المتغيرات
[$a, $b, $c] = $array;

//"a", "b", "c" والمفاتيح $array إلى عناصر المصفوفة $a,$b,$c إسناد قيم المتغيرات
["a" => $a, "b" => $b, "c" => $c] = $array;

الدالة array_reduce

تختزل الدالة array_reduce المصفوفة إلى قيمة واحدة. تمرّ الدالة على كل عنصر من عناصر المصفوفة بنتيجة مُعادة من التكرار السابق وتنتج قيمة جديدة تحتفظ بها للتكرار التالي.

الاستخدام:

array_reduce ($array, function($carry, $item){...}, $defaul_value_of_first_carry)

‎$carry‎ هي النتيجة المعادة من التكرار السابق و‎$item يحمل قيمة التكرار الحالي.

مجموع مصفوفة

$result = array_reduce([1, 2, 3, 4, 5], function($carry, $item){
    return $carry + $item;
});

// 15

أكبر عدد في المصفوفة

$result = array_reduce([10, 23, 211, 34, 25], function($carry, $item){
    return $item > $carry ? $item : $carry;
});

// 211

هل كل العناصر أكبر من 100

$result = array_reduce([101, 230, 210, 341, 251], function($carry, $item){
return $carry && $item > 100;
}, true); 
// true يجب أن تكون القيمة الافتراضية

// true

هل يوجد عنصر أصغر من 100

$result = array_reduce([101, 230, 21, 341, 251], function($carry, $item){
return $carry || $item < 100;
}, false);
// false يجب أن تكون القيمة الافتراضية

// true

تجميع مصفوفة

$result = array_reduce(["hello", "world", "PHP", "language"], function($carry, $item){
    return !$carry ? $item : $carry . "-" . $item ;
});

// "hello-world-PHP-language"

يمكنك أيضًا كتابة تابع للتجميع:

function implode_method($array, $piece){
    return array_reduce($array, function($carry, $item) use ($piece) {
        return !$carry ? $item : ($carry . $piece . $item);
    });
}

$result = implode_method(["hello", "world", "PHP", "language"], "-");

// "hello-world-PHP-language"

دفع عنصر إلى نهاية مصفوفة

يوجد طريقتين لدفع عنصر إلى مصفوفة: الدالة array_push()‎ و‎$array[] =‎.

نستخدم الدالة array_push()‎ كما يلي:

$array = [1,2,3];
$newArraySize = array_push($array, 5, 6);
// يُرجع التابع الحجم الجديد للمصفوفة

print_r($array);
// تُمرّر المصفوفة بالمرجع لذا تُعدّل المصفوفة الأساسية لتحتوي العناصر الجديدة

ستطبع الشيفرة:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 5
    [4] => 6
)

نستخدم ‎$array[] =‎ كالتالي:

$array = [1,2,3];
$array[] = 5;
$array[] = 6;
print_r($array);

تطبع الشيفرة السابقة:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 5
    [4] => 6
)

ترشيح (Filtering) مصفوفة

نستخدم الدالة array_filter لترشيح قيم من المصفوفة والحصول على مصفوفة جديدة تحقق كل شروط المُرشِّح.

ترشيح القيم غير الفارغة

أفضل حالة للترشيح هي إزالة جميع القيم الفارغة:

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$non_empties = array_filter($my_array); // $non_empties will contain
// [1,2,3,4,5,6,7,8] هو $non_empties يصبح محتوى المصفوفة

الترشيح برد النداء

بفرض أننا نريد الحصول على القيم الزوجية فقط:

$my_array = [1,2,3,4,5,6,7,8];

$even_numbers = array_filter($my_array, function($number) {
    return $number % 2 === 0;
});

تستقبل الدالة array_filter المصفوفة التي نريد ترشيحها في الوسيط الأول أما الوسيط الثاني فهو المُرشِّح الذي نريد تطبيقه.

الإصدار PHP 5.6 وما بعده

الترشيح تبعًا للفهرس

يمكننا تمرير معامل ثالث للدالة array_filter يسمح بتعديل القيم الممررة إلى رد النداء، يمكن ضبط هذا المعامل على أنّه ARRAY_FILTER_USE_KEY أو ARRAY_FILTER_USE_BOTH، وهو يسمح أن يستقبل رد النداء المفاتيح بدلًا من القيم أو كلًا من المفاتيح والقيم كوسطاء. فإذا أردت التعامل مع الفهارس بدلًا من القيم مثلًا:

$numbers = [16,3,5,8,1,4,6];

$even_indexed_numbers = array_filter($numbers, function($index) {
    return $index % 2 === 0;
}, ARRAY_FILTER_USE_KEY);

الفهارس في المصفوفة المرشَّحة

لاحظ أنّ الدالة array_filter تحافظ على مفاتيح المصفوفة الأصلية، ومن الخطأ أن تقوم بتنفيذ حلقة for على المصفوفة المُرشَّحة:

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];

$filtered = array_filter($my_array);

// إظهار كل الأخطاء والملاحظات
error_reporting(E_ALL); 


// for من الخطأ استخدام حلقة
for ($i = 0; $i < count($filtered); $i++) {
    print $filtered[$i];
}

/*
:الخرج
1
Notice: Undefined offset: 1
2
Notice: Undefined offset: 3
3
Notice: Undefined offset: 5
4
Notice: Undefined offset: 7
*/

حدث هذا لأن قيم الفهارس 1، 3، 5، 7 التي هي 0، null، سلسلة فارغة ”، مصفوفة فارغة [] على الترتيب قد حُذفت مع فهارسها.

إذا كنت تحتاج تمرير حلقة على نتيجة مُرشِّح طُبِّق على مصفوفة مفهرسة، يجب أن تستدعي الدالة array_values لنتيجة الدالة array_filter لتُنشئ مصفوفة جديدة مع فهارس صحيحة:

$my_array = [1,0,2,null,3,'',4,[],5,6,7,8];
$filtered = array_filter($my_array);
$iterable = array_values($filtered);

error_reporting(E_ALL); // إظهار كل الأخطاء والملاحظات

for ($i = 0; $i < count($iterable); $i++) {
    print $iterable[$i];
}
// لا يوجد تحذيرات

إزالة عناصر من مصفوفة

لإزالة عنصر من مصفوفة مثلًا العنصر الذي فهرسه 1:

$fruit = array("bananas", "apples", "peaches");
unset($fruit[1]);

ستزيل الشيفرة السابقة العنصر apples من المصفوفة لكن لاحظ أنّ الدالة unset لا تغيّر فهارس باقي العناصر لذا فإنّ المصفوفة ‎$fruit تحتوي الآن الفهارس 0 و2.

يمكنك الحذف في المصفوفات الترابطية كما يلي:

$fruit = array('banana', 'one'=>'apple', 'peaches');

print_r($fruit);

/*
Array
(
    [0] => banana
    [one] => apple
    [1] => peaches
)
*/

unset($fruit['one']);

تصبح الآن المصفوفة ‎$fruit:

print_r($fruit);

/*
Array
(
    [0] => banana
    [1] => peaches
)
*/

لاحظ أنّ الشيفرة التالية:

unset($fruit);

تزيل تعيين المتغير لذا تحذف كامل المصفوفة أي أنّه لم يعد بإمكاننا الوصول إلى أي عنصر من عناصرها.

إزالة عناصر الأطراف

تُزيل الدالة array_shift()‎ عنصرًا من بداية المصفوفة.

مثال:

$fruit = array("bananas", "apples", "peaches");
array_shift($fruit);
print_r($fruit);

الخرج:

Array
(
    [0] => apples
    [1] => peaches
)

تُزيل الدالة array_pop()‎ عنصرًا من نهاية المصفوفة.

مثال:

$fruit = array("bananas", "apples", "peaches");
array_pop($fruit);
print_r($fruit);

الخرج:

Array
(
    [0] => bananas
    [1] => apples
)

ترتيب مصفوفة

يوجد عدة دوال لترتيب المصفوفات في PHP:

الدالة sort()‎

ترتّب هذه الدالة عناصر المصفوفة ترتيبًا تصاعديًّا وفقًا لقيمها.

$fruits = ['Zitrone', 'Orange', 'Banane', 'Apfel'];
sort($fruits);
print_r($fruits);

/*
Array
(
    [0] => Apfel
    [1] => Banane
    [2] => Orange
    [3] => Zitrone
)
*/

الدالة rsort()‎

ترتّب هذه الدالة عناصر المصفوفة ترتيبًا تنازليًّا وفقًا لقيمها.

$fruits = ['Zitrone', 'Orange', 'Banane', 'Apfel'];
rsort($fruits);
print_r($fruits);

/*
Array
(
    [0] => Zitrone
    [1] => Orange
    [2] => Banane
    [3] => Apfel
)
*/

الدالة asort()‎

تُرتِّب هذه الدالة عناصر المصفوفة ترتيبًا تصاعديًّا وتحافظ على اقتران الفهارس مع القيم المرتبطة بها.

$fruits = [1 => 'lemon', 2 => 'orange', 3 => 'banana', 4 => 'apple'];
asort($fruits);
print_r($fruits);

/*
Array
(
    [4] => apple
    [3] => banana
    [1] => lemon
    [2] => orange
)
*/

الدالة arsort()‎

تُرتِّب هذه الدالة عناصر المصفوفة ترتيبًا تنازليًّا وتحافظ على اقتران الفهارس مع القيم المرتبطة بها.

$fruits = [1 => 'lemon', 2 => 'orange', 3 => 'banana', 4 => 'apple'];
arsort($fruits);
print_r($fruits);

/*
Array
(
    [2] => orange
    [1] => lemon
    [3] => banana
    [4] => apple
)
*/

الدالة ksort()‎

تُرتّب هذه الدالة المصفوفة ترتيبًا تصاعديًّا حسب المفتاح.

$fruits = ['d'=>'lemon', 'a'=>'orange', 'b'=>'banana', 'c'=>'apple'];
ksort($fruits);
print_r($fruits);

/*
Array
(
    [a] => orange
    [b] => banana
    [c] => apple
    [d] => lemon
)
*/

الدالة krsort()‎

تُرتّب هذه الدالة المصفوفة ترتيبًا تنازليًّا حسب المفتاح.

$fruits = ['d'=>'lemon', 'a'=>'orange', 'b'=>'banana', 'c'=>'apple'];
krsort($fruits);
print_r($fruits);

/*
Array
(
    [d] => lemon
    [c] => apple
    [b] => banana
    [a] => orange
)
*/

الدالة natsort()‎

ترتّب هذه الدالة المصفوفة بنفس الطريقة التي يرتّب بها الإنسان (ترتيب طبيعي).

$files = ['File8.stack', 'file77.stack', 'file7.stack', 'file13.stack', 'File2.stack'];
natsort($files);
print_r($files);

/*
Array
(
    [4] => File2.stack
    [0] => File8.stack
    [2] => file7.stack
    [3] => file13.stack
    [1] => file77.stack
)
*/

الدالة natcasesort()‎

ترتّب هذه الدالة المصفوفة بنفس الطريقة التي يرتّب بها الإنسان (ترتيب طبيعي) لكن غير حساسة لحالة الأحرف.

$files = ['File8.stack', 'file77.stack', 'file7.stack', 'file13.stack', 'File2.stack'];
natcasesort($files);
print_r($files);

/*
Array
(
    [4] => File2.stack
    [2] => file7.stack
    [0] => File8.stack
    [3] => file13.stack
    [1] => file77.stack
)
*/

الدالة shuffle()‎

تخلط هذه الدالة عناصر المصفوفة (ترتيب عشوائي).

$array = ['aa', 'bb', 'cc'];
shuffle($array);
print_r($array);

بما أنّ الترتيب عشوائي فليس هناك نتيجة واحدة محددة للشيفرة السابقة، فقد تكون مثلًا:

Array
(
    [0] => cc
    [1] => bb
    [2] => aa
)

الدالة usort()‎

ترتّب هذه الدالة المصفوفة باستخدام دالة موازنة معرّفة من قبل المستخدم.

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$array = [3, 2, 5, 6, 1];
usort($array, 'compare');
print_r($array);

/*
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 5
    [4] => 6
)
*/

الدالة uasort()‎

ترتّب هذه الدالة المصفوفة باستخدام دالة موازنة معرّفة من قبل المستخدم وتحافظ على ارتباط الفهارس بالقيم المقابلة.

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$array = ['a' => 1, 'b' => -3, 'c' => 5, 'd' => 3, 'e' => -5];
uasort($array, 'compare');
print_r($array);

/*
Array
(
    [e] => -5
    [b] => -3
    [a] => 1
    [d] => 3
    [c] => 5
)
*/

الدالة uksort()‎

ترتّب هذه الدالة المصفوفة حسب المفاتيح باستخدام دالة موازنة معرّفة من قبل المستخدم.

function compare($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$array = ['ee' => 1, 'g' => -3, '4' => 5, 'k' => 3, 'oo' => -5];
uksort($array, 'compare');
print_r($array);

/*
Array
(
    [ee] => 1
    [g] => -3
    [k] => 3
    [oo] => -5
    [4] => 5
)
*/

إضافة بعض مفاتيح المصفوفة إلى اللائحة البيضاء

يمكنك استخدام الدالتين array_intersect_key وarray_flip معًا عندما تريد السماح بوجود مفاتيح محددة فقط في المصفوفة خاصةً عندما تأتي المفاتيح من معاملات طلب ما.

$parameters = ['foo' => 'bar', 'bar' => 'baz', 'boo' => 'bam'];
$allowedKeys = ['foo', 'bar'];
$filteredParameters = array_intersect_key($parameters, array_flip($allowedKeys));

// $filteredParameters = ['foo' => 'bar', 'bar' => 'baz]

إذا لم يحتوي متغير المعاملات على أي مفتاح مسموح به فإنّ المتغير filteredParameters سيكون مصفوفة فارغة.

ويمكنك أيضًا استخدام الدالة array_filter لنفس الوظيفة بدءًا من الإصدار PHP 5.6، ممررًا الراية ARRAY_FILTER_USE_KEY كمعامل ثالث.

$parameters = ['foo' => 1, 'hello' => 'world'];
$allowedKeys = ['foo', 'bar'];

$filteredParameters = array_filter(
    $parameters,
    function ($key) use ($allowedKeys) {
        return in_array($key, $allowedKeys);
    },
    ARRAY_FILTER_USE_KEY
);

يوفر استخدام الدالة arrayfilter مرونةً إضافيةً لإجراء اختبار عشوائي على المفاتيح، فمثلًا يمكن أن تحتوي المصفوفة ‎$allowedKeys أنماطًا تعبيرية بدلًا من السلاسل النصية العادية، كما أنّها تذكر الهدف من الشيفرة بشكلٍ أكثر صراحة من الدالتين array_intersect_key وarray_flip.

إضافة عنصر إلى بداية المصفوفة

يمكنك استخدام الدالة array_unshift()‎ عند الحاجة إلى إضافة عنصر في بداية المصفوفة دون تغيير في ترتيب العناصر الحالية، إذ تضيف هذه الدالة العناصر الممررة بالكامل إلى بداية المصفوفة فتبقى العناصر الممررة بنفس الترتيب، وتعدَّل جميع المفاتيح العددية لتبدأ من الصفر بينما تبقى المفاتيح التي تكون بشكل سلسلة نصية كما هي.

$myArray = array(1, 2, 3);
array_unshift($myArray, 4);
print_r($myArray);

// Array ( [0] => 4 [1] => 1 [2] => 2 [3] => 3 )

بما أنّ الدالة array_unshift()‎ تُجبر المصفوفة على إعادة تعيين أزواج مفتاح – قيمة والعنصر الجديد يجعل مفاتيح المداخل التالية تبدأ من n+1 فمن الأسهل إنشاء مصفوفة جديدة وإضافة المصفوفة الحالية إلى المصفوفة المُنشأة حديثًا.

مثال:

$myArray = array('apples', 'bananas', 'pears');
$myElement = array('oranges');
$joinedArray = $myElement;

foreach ($myArray as $i) {
    $joinedArray[] = $i;
}

// Array ( [0] => oranges [1] => apples [2] => bananas [3] => pears )

يمكنك الاطلاع على المثال هنا

تبادل القيم مع المفاتيح

تستبدل الدالة array_flip()‎ كل مفاتيح المصفوفة بالقيم المرتبطة معها.

$colors = array(
    'one' => 'red',
    'two' => 'blue',
    'three' => 'yellow',
);

array_flip($colors); 

/*
array(
    'red' => 'one',
    'blue' => 'two',
    'yellow' => 'three'
)
*/

دمج مصفوفتين في مصفوفة واحدة

تدمج الدالة array_merge()‎ مصفوفتين أو أكثر.

$a1 = array("red","green");
$a2 = array("blue","yellow");
print_r(array_merge($a1,$a2));

/*
    Array ( [0] => red [1] => green [2] => blue [3] => yellow )
*/

المصفوفة الترابطية:

$a1=array("a"=>"red","b"=>"green");
$a2=array("c"=>"blue","b"=>"yellow");
print_r(array_merge($a1,$a2));
/*
    Array ( [a] => red [b] => yellow [c] => blue )
*/
  • تُدمج العناصر من مصفوفة أو واحدة أكثر فتُضاف قيم إحداها إلى نهاية المصفوفة الأخرى وتُرجع المصفوفة النهائية.
  • إذا كان لمصفوفات الدخل نفس المفاتيح المكونة من سلاسل نصية فإنّ القيمة اللاحقة للمفتاح ستكتب فوق القيمة السابقة له أما إذا كانت المفاتيح عددية فإنّ القيمة اللاحقة ستُضاف ولن تكتب فوق القيمة السابقة للمفتاح.
  • إذا كانت مفاتيح مصفوفة الدخل رقمية سيُعاد ترقيم القيم في مصفوفة النتيجة بمفاتيح تزايدية ابتداءً من الصفر.

معالجة عدة مصفوفات معًا

تقاطع (intersection) المصفوفات

تُرجع الدالة array_intersect مصفوفة من القيم الموجودة في جميع المصفوفات الممررة إليها وتحافظ على المفاتيح المرتبطة مع القيم المعادة.

$array_one = ['one', 'two', 'three'];
$array_two = ['two', 'three', 'four'];
$array_three = ['two', 'three'];

$intersect = array_intersect($array_one, $array_two, $array_three);

// $intersect = ['two', 'three']

تتحقق الدالة array_intersect من قيم المصفوفات فقط أما الدالة array_intersect_assoc تُرجع تقاطع القيم مع المفاتيح المرتبطة بها.

$array_one = [1 => 'one',2 => 'two',3 => 'three'];
$array_two = [1 => 'one', 2 => 'two', 3 => 'two', 4 => 'three'];
$array_three = [1 => 'one', 2 => 'two'];

$intersect = array_intersect_assoc($array_one, $array_two, $array_three);

// $intersect = [1 =>'one',2 => 'two']

تتحقق الدالة array_intersect_key من التقاطع بتفحص المفاتيح فقط وتُرجع المفاتيح الموجودة في جميع المصفوفات الممررة.

$array_one = [1 => 'one',2 => 'two',3 => 'three'];
$array_two = [1 => 'one', 2 => 'two', 3 => 'four'];
$array_three = [1 => 'one', 3 => 'five'];

$intersect = array_intersect_key($array_one, $array_two, $array_three);

// $intersect = [1 =>'one',3 => 'three']

دمج أو ضم مصفوفتين

$fruit1 = ['apples', 'pears'];
$fruit2 = ['bananas', 'oranges'];
$all_of_fruits = array_merge($fruit1, $fruit2);

//$all_of_fruits = [0 => 'apples', 1 => 'pears', 2 => 'bananas', 3 => 'oranges']

لاحظ أنّ الدالة array_merge()‎ ستغيّر الفهارس الرقمية وتكتب فوق الفهارس النصية.

$fruit1 = ['one' => 'apples', 'two' => 'pears'];
$fruit2 = ['one' => 'bananas', 'two' => 'oranges'];
$all_of_fruits = array_merge($fruit1, $fruit2);

//$all_of_fruits = ['one' => 'bananas', 'two' => 'oranges']

تعيد الدالة array_merge()‎ كتابة قيم المصفوفة الثانية فوق قيم المصفوفة الأولى إذا لم تستطع إعادة ترقيم فهارسها.

يمكنك استخدام العامل + لدمج مصفوفتين بطريقة لا يمكن فيها للقيم أن يُكتب فوقها لكنها لا تُعيد ترقيم الفهارس العددية لذا تخسر قيم المصفوفات التي لها فهرس مُستخدم في المصفوفة الأولى.

$fruit1 = ['one' => 'apples', 'two' => 'pears'];
$fruit2 = ['one' => 'bananas', 'two' => 'oranges'];
$all_of_fruits = $fruit1 + $fruit2;

// $all_of_fruits = ['one' => 'apples', 'two' => 'pears']

$fruit1 = ['apples', 'pears'];
$fruit2 = ['bananas', 'oranges'];
$all_of_fruits = $fruit1 + $fruit2;

// $all_of_fruits = [0 => 'apples', 1 => 'pears']

تغيير مصفوفة متعددة الأبعاد إلى مصفوفة ترابطية

إذا كان لديك مصفوفة متعددة الأبعاد مثل:

[
    ['foo', 'bar'],
    ['fizz', 'buzz'],
]

وتريد تغييرها إلى مصفوفة ترابطية مثل:

[
    'foo' => 'bar',
    'fizz' => 'buzz',
]

فيمكنك استخدام الشيفرة التالية:

$multidimensionalArray = [
    ['foo', 'bar'],
    ['fizz', 'buzz'],
];

$associativeArrayKeys   = array_column($multidimensionalArray, 0);
$associativeArrayValues = array_column($multidimensionalArray, 1);
$associativeArray       = array_combine($associativeArrayKeys, $associativeArrayValues);

أو يمكنك تخطي الإعداد ‎$associativeArrayKeys و‎$associativeArrayValues واستخدام الشيفرة البسيطة التالية:

$associativeArray = array_combine(array_column($multidimensionalArray, 0),
array_column($multidimensionalArray, 1));

جمع مصفوفتين (المفاتيح من واحدة والقيم من الأخرى)

تنشئ الدالة array_combine() مصفوفةً جديدةً عن طريق استخدام المفاتيح من أحد المصفوفات والقيم من مصفوفة أخرى.

يبين المثال التالي كيفية دمج مصفوفتين في مصفوفة واحدة ترابطية فيها المفاتيح من المصفوفة الأولى والقيم من المصفوفة الثانية:

$array_one = ['key1', 'key2', 'key3'];
$array_two = ['value1', 'value2', 'value3'];
$array_three = array_combine($array_one, $array_two);
var_export($array_three);

/*
array (
    'key1' => 'value1',
    'key2' => 'value2',
    'key3' => 'value3',
)
*/

مكتبة PHP المعيارية لهياكل البيانات (SPL)

SplFixedArray

الاختلاف عن مصفوفة PHP

يُنفَّذ نوع المصفوفة الافتراضي في PHP كخرائط hash مرتبة مما يسمح لنا بإنشاء مصفوفات تحتوي على الأزواج قيمة/مفتاح، يمكن أن تكون القيم من أي نوع والمفاتيح إما أرقام أو سلاسل نصية، ومع ذلك فإنّ هذه ليست الطريقة التقليدية لإنشاء المصفوفات.

01.PNG

كما تلاحظ في الرسم التوضيحي فإنّه من الممكن أن تُعرض مصفوفة PHP مثل مجموعة مرتبة من الأزواج قيمة/مفتاح حيث يُربَط كل مفتاح إلى أي قيمة. لاحظ أنّه في هذه المصفوفة لدينا مفاتيح عددية ومفاتيح بشكل سلاسل نصية بالإضافة إلى قيم من أنواع مختلفة والمفتاح ليس له تأثير على ترتيب العناصر.

$arr = [
    9 => "foo",
    1 => 4.2,
    "bar" => null,
];
foreach($arr as $key => $value) {
    echo "$key => $valuen";
}

تعطينا الشيفرة السابقة ما نتوقعه تمامًا:

9 => foo 1 => 4.2 bar =>

يُحدد حجم مصفوفات PHP العادية ديناميكيًا، ويزداد وينقص هذا الحجم بإضافة أو حذف عناصر إلى ومن المصفوفة بشكلٍ تلقائي، أما في المصفوفات التقليدية يكون الحجم ثابتًا وتتألف المصفوفة بالكامل من نفس نوع القيم ويمكننا الوصول إلى أي قيمة باستخدام الفهارس بدلًا من المفاتيح ويمكن استنتاج الفهرس من إزاحة القيمة في المصفوفة.

02.PNG

وبما أننا سنعرف حجم نوع معين والحجم الثابت للمصفوفة فإنّ الإزاحة هي حجم النوع * n، إذ تمثّل n موضع القيمة في المصفوفة، يعطينا ‎$arr[0]‎ في المثال السابق القيمة 1 ويعطينا العنصر الأول في المصفوفة ‎$arr[1]‎ القيمة 2 وهكذا…

ومع ذلك لا يقيّد الصنف SplFixedArray نوع القيم إنما يقيد نوع المفاتيح فقط والتي يجب أن تكون عددية، ?وأيضًا ذات حجم ثابت، وهذا يجعل المصفوفات من النوع SplFixedArray أكثر فعاليةٍ من المصفوفات العادية بطريقةٍ معينة فهي أصغر وتتطلب ذاكرة أقل.

تهيئة المصفوفة

تُنفَّذ المصفوفة من النوع SplFixedArray ككائن لكن يمكن الوصول إليها بنفس الصياغة التي نصل فيها إلى مصفوفة PHP العادية بما أنّها تنفّذ الواجهة ArrayAccess وتنفّذ أيضًا الواجهات Countable وIterator لذا لها نفس سلوك مصفوفات PHP العادية الذي اعتدت عليه (أي الأشياء مثل ‎count(‎$arr)‎ وforeach($arr as $k => $v)‎ تعمل بنفس الطريقة في المصفوفات من النوع SplFixedArray والمصفوفات العادية).

يأخذ باني المصفوفة من النوع SplFixedArray وسيطًا واحدًا يعبّر عن حجم المصفوفة.

$arr = new SplFixedArray(4);
$arr[0] = "foo";
$arr[1] = "bar";
$arr[2] = "baz";
foreach($arr as $key => $value) {
    echo "$key => $valuen";
}

تعطيك الشيفرة السابقة النتيجة:

0 => foo 1 => bar 2 => baz 3 =>

كما أنّ الشيفرة:

var_dump(count($arr));

تعطينا ما نتوقع:

int(4)

لاحظ أنه في المصفوفات من النوع SplFixedArray يصف المفتاح ترتيب العنصر في المصفوفة لأنه فهرس حقيقي وليس مجرد خريطة كما في المصفوفات العادية.?

تغيير حجم المصفوفة

تذكر دائمًا بما أنّ المصفوفة ذات حجم ثابت فإنّ عدّها سيعيد دائمًا القيمة نفسها، لذا طالما أنّ نتيجة unset($arr[1])‎ هي ‎$arr[1] === null‎ تبقى نتيجة count($arr)‎ هي 4، وتحتاج لتغيير حجم المصفوفة إلى استدعاء التابع setSize:

$arr->setSize(3);

var_dump(count($arr));

foreach($arr as $key => $value) {
    echo "$key => $valuen";
}

الآن نحصل على النتيجة:

int(3) 0 => foo 1 => 2 => baz

الاستيراد من SplFixedArray والتصدير إلى SplFixedArray

يمكنك استيراد/تصدير مصفوفة عادية إلى/من مصفوفة SplFixedArray باستخدام التوابع fromArray وtoArray.

$array = [1,2,3,4,5];
$fixedArray = SplFixedArray::fromArray($array);

foreach($fixedArray as $value) {
    echo $value, "n";
}
// 1 2 3 4 5

$fixedArray = new SplFixedArray(5);
$fixedArray[0] = 1;
$fixedArray[1] = 2;
$fixedArray[2] = 3;
$fixedArray[3] = 4;
$fixedArray[4] = 5;

$array = $fixedArray->toArray();
foreach($array as $value) {
    echo $value, "n";
}
// 1 2 3 4 5

ترجمة -وبتصرف- للفصول [Executing Upon an Array – Manipulating an Array – Processing Multiple Arrays Together – SPL data structures] من كتاب PHP Notes for Professionals book


Source link

اظهر المزيد
زر الذهاب إلى الأعلى

أنت تستخدم إضافة Adblock

الاعلانات هي مصدرنا الوحيد لدفع التكلفة التشغيلية لهذا المشروع الريادي يرجى الغاء تفعيل حاجب الأعلانات