Arti Tiga titik (…) di PHP

Apa Arti Tiga Titik (...) di PHP?

Saat saya menginstal Magento 2 di Sever saya, saya mendapat kesalahan. Selidiki kode tersebut dan temukan bahwa ada Tiga titik (...), yang menghasilkan kesalahan. Saya menyebutkan kode di bawah ini

return new $type(...array_values($args));

Ini ...$strdisebut operator percikan di PHP .

Fitur ini memungkinkan Anda untuk menangkap sejumlah variabel argumen ke suatu fungsi, dikombinasikan dengan argumen "normal" yang diteruskan jika Anda mau. Paling mudah dilihat dengan contoh:

function concatenate($transform, ...$strings) {
    $string = '';
    foreach($strings as $piece) {
        $string .= $piece;
    }
    return($transform($string));
}

echo concatenate("strtoupper", "I'd ", "like ", 4 + 2, " apples");
// This would print:
// I'D LIKE 6 APPLES

Daftar parameter dalam deklarasi fungsi memiliki ...operator di dalamnya, dan pada dasarnya berarti "... dan yang lainnya harus menjadi $ string". Anda dapat mengirimkan 2 atau lebih argumen ke dalam fungsi ini dan yang kedua dan selanjutnya akan ditambahkan ke array $ strings, siap digunakan.

Semoga ini membantu!

Setiap jawaban mengacu pada posting blog yang sama, selain itu, berikut adalah dokumentasi resmi tentang daftar argumen panjang-variabel :

http://php.net/manual/en/functions.arguments.php#functions.variable-arg-list

Di PHP 5.6 dan yang lebih baru, daftar argumen mungkin menyertakan ... token untuk menunjukkan bahwa fungsi tersebut menerima sejumlah variabel argumen. Argumen akan diteruskan ke variabel yang diberikan sebagai array

Sepertinya operator "percikan" bukanlah nama resmi, tetap saja lucu!

Ada DUA kegunaan untuk elipsis (...) token PHP — anggap saja mereka sebagai pengepakan sebuah array dan membongkar sebuah array. Kedua tujuan tersebut berlaku untuk argumen fungsi.

Pak

Saat mendefinisikan sebuah fungsi, jika Anda memerlukan sejumlah variabel dinamis yang disediakan untuk fungsi tersebut (yaitu, Anda tidak tahu berapa banyak argumen yang akan diberikan ke fungsi itu ketika dipanggil dalam kode) gunakan token elipsis (...) untuk menangkap semua argumen tersisa yang disediakan untuk fungsi itu ke dalam larik yang dapat diakses di dalam blok fungsi. Jumlah argumen dinamis yang ditangkap oleh elipsis (...) bisa nol atau lebih.

Contoh :

// function definition
function sum(...$numbers) { // use ellipsis token when defining function
    $acc = 0;
    foreach ($numbers as $nn) {
        $acc += $nn;
    }
    return $acc;
}

// call the function
echo sum(1, 2, 3, 4); // provide any number of arguments

> 10

// and again...
echo sum(1, 2, 3, 4, 5);

> 15

// and again...
echo sum();

> 0

Ketika pengepakan digunakan dalam fungsi instantiation, elipsis (...) menangkap semua argumen yang tersisa , yaitu, Anda masih dapat memiliki sejumlah argumen awal, tetap (posisi):

function sum($first, $second, ...$remaining_numbers) {
    $acc = $first + $second;
    foreach ($remaining_numbers as $nn) {
        $acc += $nn;
    }
    return $acc;
}

// call the function
echo sum(1, 2); // provide at least two arguments

> 3

// and again...
echo sum(1, 2, 3, 4); // first two are assigned to fixed arguments, the rest get "packed"

> 10

Membongkar

Alternatifnya, saat memanggil fungsi, jika argumen yang Anda berikan ke fungsi itu sebelumnya digabungkan ke dalam array, gunakan token elipsis (...) untuk mengonversi array itu menjadi argumen individual yang disediakan untuk fungsi — setiap elemen array ditetapkan ke masing-masing variabel argumen fungsi dinamai dalam definisi fungsi.

Sebagai contoh:

function add($aa, $bb, $cc) {
    return $aa + $bb + $cc;
}

$arr = [1, 2, 3];
echo add(...$arr); // use ellipsis token when calling function

> 6

$first = 1;
$arr = [2, 3];
echo add($first, ...$arr); // used with positional arguments

> 6

$first = 1;
$arr = [2, 3, 4, 5]; // array can be "oversized"
echo add($first, ...$arr); // remaining elements are ignored

> 6

Pembongkaran sangat berguna saat menggunakan fungsi array untuk memanipulasi array atau variabel.

Misalnya, membongkar hasil dari array_slice :

function echoTwo ($one, $two) {
    echo "$one\n$two";
}

$steaks = array('ribeye', 'kc strip', 't-bone', 'sirloin', 'chuck');

// array_slice returns an array, but ellipsis unpacks it into function arguments
echoTwo(...array_slice($steaks, -2)); // return last two elements in array

> sirloin
> chuck

Untuk menggunakan fitur ini, cukup peringatkan PHP bahwa ia perlu mengekstrak array menjadi variabel menggunakan ... operator. Lihat di sini untuk lebih jelasnya, contoh sederhana bisa terlihat seperti ini:

$email[] = "Hi there";
$email[] = "Thanks for registering, hope you like it";

mail("[email protected]", ...$email);

Artinya adalah ia mendekomposisi array asosiatif menjadi daftar. Jadi, Anda tidak perlu mengetikkan parameter N untuk memanggil metode, cukup satu. Metode If memungkinkan parameter terdekomposisi dan jika parameter memiliki tipe yang sama.

Bagi saya, hal terpenting tentang operator percikan adalah dapat membantu untuk mengetikkan parameter array:

$items = [
    new Item(), 
    new Item()
];

$collection = new ItemCollection();
$collection->add(...$items); // !

// what works as well:
// $collection->add(new Item());
// $collection->add(new Item(), new Item(), new Item()); // :(

class Item  {};

class ItemCollection {

    /**
     * @var Item[]
     */
    protected $items = [];

    public function add(Item ...$items)
    {
        foreach ($items as &$item) {
            $this->items[] = $item;
        }
    }
} 

ini menghemat beberapa upaya pada kontrol tipe, terutama saat bekerja dengan koleksi besar atau sangat berorientasi objek.

Penting untuk diperhatikan adalah bahwa ...$arraymelakukan dekomposisi sebuah array terlepas dari tipe itemnya , jadi Anda juga bisa melakukannya dengan cara yang jelek:

function test(string $a, int $i) {
    echo sprintf('%s way as well', $a);

    if ($i === 1) {
        echo('!');
    }
}

$params = [
    (string) 'Ugly',
    (int) 1
];

test(...$params);

// Output:
// Ugly way as well!

Tapi tolong jangan.

Inilah yang disebut operator "percikan". Pada dasarnya hal itu diterjemahkan menjadi "sejumlah argumen"; diperkenalkan dengan PHP 5.6

Lihat di sini untuk detail lebih lanjut.

Sepertinya tidak ada yang menyebutkannya, jadi di sini untuk tinggal [Ini juga akan membantu Google (& SE lainnya) memandu pengembang yang meminta Parameter Istirahat di PHP ]:

Seperti yang ditunjukkan di sini yang disebut Parameter Istirahat di JS & saya lebih suka penamaan yang bermakna ini daripada benda percikan itu!

Di PHP, Fungsionalitas yang disediakan oleh ... args disebut fungsi Variadic yang diperkenalkan pada PHP5.6. Fungsionalitas yang sama digunakan untuk diimplementasikan menggunakan func_get_args().

Untuk menggunakannya dengan benar, Anda harus menggunakan sintaks parameter istirahat, di mana pun itu membantu mengurangi kode boilerplate .

Di PHP 7.4 elipsis juga merupakan operator Spread :

$parts = ['apple', 'pear'];
$fruits = ['banana', 'orange', ...$parts, 'watermelon'];
// ['banana', 'orange', 'apple', 'pear', 'watermelon'];

Sumber: https://wiki.php.net/rfc/spread_operator_for_array

Saya ingin berbagi penggunaan operator ini dalam kerangka Magento, di mana ia memberi contoh objek dengan parameter yang dapat dikonfigurasi dinamis (pikirkan file konfigurasi XML).

Seperti yang dapat kita lihat createObjectfungsi dari potongan kode berikut, ini mengambil array argumen yang disiapkan untuk pembuatan objek. Kemudian menggunakan ...operator (tiga titik) untuk meneruskan nilai array sebagai argumen nyata ke konstruktor kelas.

<?php

namespace Magento\Framework\ObjectManager\Factory;

abstract class AbstractFactory implements \Magento\Framework\ObjectManager\FactoryInterface
{
    ...

    /**
     * Create object
     *
     * @param string $type
     * @param array $args
     *
     * @return object
     * @throws RuntimeException
     */
    protected function createObject($type, $args)
    {
        try {
            return new $type(...array_values($args));
        } catch (\TypeError $exception) {
            ...
        }
    }

    ...

}

itu adalah operator percikan atau pencar di PHP

referensi: operator percikan atau pencar di PHP

Versi 5.6 menambahkan operator percikan atau terkadang disebut pembongkaran argumen. Operator percikan adalah 3 titik sebelum parameter. Operator percikan memungkinkan pengguna untuk mengirimkan sejumlah parameter yang berubah-ubah. Parameter arbitrer kemudian diubah menjadi array oleh PHP.

Jadi apa perbedaan antara menggunakan operator percikan dan array atau array asosiatif. Anda dapat menentukan tipe data dari objek yang ditugaskan ke operator percikan dan jika mereka tidak cocok dengan php akan membuat kesalahan.

function addItemsToCart(CartItem ...$cartItems) {
    //$cartItems is an array of CartItem objects
}

$cartItem1 = new CartItem();
$cartItem2 = new CartItem();
$cartItem3 = new CartItem();

addItemsToCart($cartItem1, $cartItem2, $cartItem3);

ref: Di sini