PHP
Arrays

परिचय

वाक्य - विन्यास

• $ array = array ('Value1', 'Value2', 'Value3'); // कुंजी 0, 1, 2, ..., के लिए डिफ़ॉल्ट है
• $ सरणी = सरणी ('Value1', 'Value2'); // वैकल्पिक अनुगामी अल्पविराम
• $ सरणी = सरणी ('की 1' => 'मूल्य 1', 'की 2' => 'मूल्य 2'); // स्पष्ट कुंजी
• $ array = array ('key1' => 'Value1', 'Value2'); // ऐरे (['key1'] => Value1 [1] => 'Value2')
• $ सरणी = ['की 1' => 'मूल्य 1', 'की 2' => 'मूल्य 2']]; // PHP 5.4+ शॉर्टहैंड
• $ सरणी [] = 'ValueX'; // सरणी के अंत में 'ValueX' जोड़ें
• $ सरणी ['कीएक्सएक्स'] = 'वैल्यूएक्स'; // 'keyX' को 'keyX' में असाइन करें
• $ सरणी + = ['कीएक्सएक्स' => 'वैल्यूएक्स', 'कीवाई' => 'वैल्यू']; // मौजूदा सरणी पर तत्वों को जोड़ना / अधिलेखित करना

पैरामीटर

टिप्पणियों

एक ऐरे को शुरू करना

एक सरणी को खाली किया जा सकता है:

// An empty array
$foo = array();

// Shorthand notation available since PHP 5.4
$foo = [];

किसी सरणी को मानों के साथ आरंभीकृत और पूर्व निर्धारित किया जा सकता है:

// Creates a simple array with three strings
$fruit = array('apples', 'pears', 'oranges');

// Shorthand notation available since PHP 5.4
$fruit = ['apples', 'pears', 'oranges'];

एक सरणी को कस्टम अनुक्रमित के साथ आरंभीकृत भी किया जा सकता है (जिसे एक सहयोगी सरणी भी कहा जाता है) :

// A simple associative array
$fruit = array(
   'first'  => 'apples',
   'second' => 'pears', 
   'third'  => 'oranges'
);

// Key and value can also be set as follows
$fruit['first'] = 'apples';

// Shorthand notation available since PHP 5.4
$fruit = [
    'first'  => 'apples', 
    'second' => 'pears', 
    'third'  => 'oranges'
];

यदि चर पहले इस्तेमाल नहीं किया गया है, तो PHP इसे स्वचालित रूप से बनाएगा। सुविधाजनक होते हुए, यह कोड को पढ़ने में कठिन बना सकता है:

$foo[] = 1;     // Array( [0] => 1 )
$bar[][] = 2;   // Array( [0] => Array( [0] => 2 ) )

सूचकांक आमतौर पर जारी रहेगा जहां आपने छोड़ा था। PHP पूर्णांक के रूप में संख्यात्मक स्ट्रिंग्स का उपयोग करने का प्रयास करेगी:

$foo = [2 => 'apple', 'melon'];  // Array( [2] => apple, [3] => melon )
$foo = ['2' => 'apple', 'melon']; // same as above
$foo = [2 => 'apple', 'this is index 3 temporarily', '3' => 'melon']; // same as above! The last entry will overwrite the second!

निश्चित आकार के साथ एक सरणी शुरू करने के लिए आप SplFixedArray उपयोग कर सकते हैं:

$array = new SplFixedArray(3);

$array[0] = 1;
$array[1] = 2;
$array[2] = 3;
$array[3] = 4; // RuntimeException

// Increase the size of the array to 10
$array->setSize(10);

नोट: SplFixedArray का उपयोग करके बनाई गई एक सरणी में डेटा के बड़े सेटों के लिए कम मेमोरी फ़ुटप्रिंट है, लेकिन कुंजी पूर्णांक होनी चाहिए।

एक सरणी को डायनामिक आकार के साथ शुरू करने के लिए लेकिन n गैर रिक्त तत्वों (जैसे प्लेसहोल्डर) के साथ आप एक लूप का उपयोग कर सकते हैं:

$myArray = array();
$sizeOfMyArray = 5;
$fill = 'placeholder';

for ($i = 0; $i < $sizeOfMyArray; $i++) {
    $myArray[] = $fill;
}

// print_r($myArray); results in the following:
// Array ( [0] => placeholder [1] => placeholder [2] => placeholder [3] => placeholder [4] => placeholder ) 

यदि आपके सभी प्लेसहोल्डर समान हैं तो आप फ़ंक्शन array_fill() का उपयोग करके भी इसे बना सकते हैं:

array array_fill (int $ start_index, int $ num, मिश्रित $ value)

यह बनाता है और साथ एक सरणी रिटर्न num की प्रविष्टियों value , कुंजी पर शुरू start_index ।

नोट: यदि start_index नकारात्मक है, तो यह नकारात्मक सूचकांक से शुरू होगा और निम्न तत्वों के लिए 0 से जारी रहेगा।

$a = array_fill(5, 6, 'banana'); // Array ( [5] => banana, [6] => banana, ..., [10] => banana)
$b = array_fill(-2, 4, 'pear'); // Array ( [-2] => pear, [0] => pear, ..., [2] => pear)

निष्कर्ष: array_fill() आप वास्तव में जो कर सकते हैं उसके लिए अधिक सीमित हैं। लूप अधिक लचीला है और आपको अवसरों की एक विस्तृत श्रृंखला खोलता है।

जब भी आप संख्याओं की श्रेणी से भरा एक सरणी चाहते हैं (जैसे 1-4) आप या तो हर एक तत्व को एक सरणी में जोड़ सकते हैं या range() फ़ंक्शन का उपयोग कर range() :

सरणी रेंज (मिश्रित $ शुरुआत, मिश्रित $ अंत [, संख्या $ कदम = 1])

यह फ़ंक्शन एक सरणी बनाता है जिसमें तत्वों की एक श्रृंखला होती है। पहले दो मापदंडों की आवश्यकता होती है, जहां वे (समावेशी) श्रेणी के प्रारंभ और अंत बिंदु निर्धारित करते हैं। तीसरा पैरामीटर वैकल्पिक है और उठाए जा रहे चरणों के आकार को परिभाषित करता है। एक बनाना range से 0 करने के लिए 4 एक साथ stepsize की 1 , जिसके परिणामस्वरूप सरणी में निम्नलिखित तत्व शामिल होंगे: 0 , 1 , 2 , 3 , और 4 । यदि चरण का आकार 2 बढ़ा दिया जाता है (यानी range(0, 4, 2) ) तो परिणामी सरणी होगी: 0 , 2 , और 4 ।

$array = [];
$array_with_range = range(1, 4);

for ($i = 1; $i <= 4; $i++) {
    $array[] = $i;
}
    
print_r($array); // Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )
print_r($array_with_range); // Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 )

range पूर्णांक, फ्लोट्स, बूलियन (जो पूर्णांक के लिए कास्ट हो जाते हैं), और स्ट्रिंग्स के साथ काम कर सकती है। हालांकि, फ़्लोटिंग पॉइंट सटीक समस्या के कारण फ़्लोट्स का उपयोग करते समय सावधानी बरती जानी चाहिए।

जाँच करें कि क्या कुंजी मौजूद है

array_key_exists() या isset() या !empty() :

$map = [
    'foo' => 1,
    'bar' => null,
    'foobar' => '',
];

array_key_exists('foo', $map); // true
isset($map['foo']); // true
!empty($map['foo']); // true

array_key_exists('bar', $map); // true
isset($map['bar']); // false
!empty($map['bar']); // false

ध्यान दें कि isset() एक null मूल्यवान तत्व को अस्तित्वहीन मानता है। जबकि !empty() किसी भी तत्व के लिए वही करता है जो false बराबर होता false (कमजोर तुलना का उपयोग करके; उदाहरण के लिए, null , '' और 0 सभी को असत्य माना जाता है !empty() )। isset($map['foobar']); true ; !empty($map['foobar']) false । इससे गलतियाँ हो सकती हैं (उदाहरण के लिए, यह भूलना आसान है कि स्ट्रिंग '0' को झूठा माना जाता है) इसलिए !empty() का उपयोग अक्सर किया जाता है।

ध्यान दें कि $map बिल्कुल भी परिभाषित नहीं होने पर isset() और !empty() काम करेगा (और गलत लौटाएगा)। इससे उनका उपयोग करने में कुछ हद तक त्रुटि होती है:

// Note "long" vs "lang", a tiny typo in the variable name.
$my_array_with_a_long_name = ['foo' => true];
array_key_exists('foo', $my_array_with_a_lang_name); // shows a warning
isset($my_array_with_a_lang_name['foo']); // returns false

आप क्रमिक सरणियों के लिए भी जाँच कर सकते हैं:

$ord = ['a', 'b']; // equivalent to [0 => 'a', 1 => 'b']

array_key_exists(0, $ord); // true
array_key_exists(2, $ord); // false

ध्यान दें कि isset() में array_key_exists() तुलना में बेहतर प्रदर्शन है क्योंकि उत्तरार्द्ध एक फ़ंक्शन है और पूर्व भाषा निर्माण है।

आप key_exists() का भी उपयोग कर सकते हैं, जो array_key_exists() लिए एक उपनाम है।

यह जाँचना कि क्या कोई मान सरणी में मौजूद है

यदि कोई आइटम किसी सरणी में मौजूद है, तो in_array() सही है।

$fruits = ['banana', 'apple'];

$foo = in_array('banana', $fruits);
// $foo value is true

$bar = in_array('orange', $fruits);
// $bar value is false

आप किसी सरणी में किसी विशिष्ट आइटम की कुंजी प्राप्त करने के लिए फ़ंक्शन array_search() का भी उपयोग कर सकते हैं।

$userdb = ['Sandra Shush', 'Stefanie Mcmohn', 'Michael'];
$pos = array_search('Stefanie Mcmohn', $userdb);
if ($pos !== false) {
    echo "Stefanie Mcmohn found at $pos";
}

$userdb = [
    [
        "uid" => '100',
        "name" => 'Sandra Shush',
        "url" => 'urlof100',
    ],
    [
        "uid" => '5465',
        "name" => 'Stefanie Mcmohn',
        "pic_square" => 'urlof100',
    ],
    [
        "uid" => '40489',
        "name" => 'Michael',
        "pic_square" => 'urlof40489',
    ]
];

$key = array_search(40489, array_column($userdb, 'uid'));

सरणी प्रकार मान्य करना

यदि वेरिएबल एक सरणी है तो फ़ंक्शन is_array() सही है।

$integer = 1337;
$array = [1337, 42];

is_array($integer); // false
is_array($array); // true

आप पैरामीटर प्रकार को लागू करने के लिए एक फ़ंक्शन में सरणी प्रकार को इंगित कर सकते हैं; और कुछ भी पारित करने के परिणामस्वरूप एक घातक त्रुटि होगी।

function foo (array $array) { /* $array is an array */ }

आप gettype() फ़ंक्शन का भी उपयोग कर सकते हैं।

$integer = 1337;
$array = [1337, 42];

gettype($integer) === 'array'; // false
gettype($array) === 'array'; // true

ArrayAccess और Iterator इंटरफेस

एक अन्य उपयोगी विशेषता PHP में सरणियों के रूप में आपके कस्टम ऑब्जेक्ट संग्रह तक पहुंच रही है। इसके समर्थन के लिए PHP (> = 5.0.0) कोर में दो इंटरफेस उपलब्ध हैं: ArrayAccess और Iterator । पूर्व आपको अपने कस्टम ऑब्जेक्ट्स को सरणी के रूप में एक्सेस करने की अनुमति देता है।

ArrayAccess

मान लें कि हमारे पास एक उपयोगकर्ता वर्ग है और सभी उपयोगकर्ताओं के लिए एक डेटाबेस तालिका है। हम एक UserCollection क्लास बनाना चाहेंगे जो:

1. हमें उनके उपयोगकर्ता नाम विशिष्ट पहचानकर्ता द्वारा कुछ उपयोगकर्ता को संबोधित करने की अनुमति दें
2. हमारे उपयोगकर्ताओं के संग्रह पर मूल (सभी CRUD नहीं, बल्कि कम से कम बनाएँ, पुनः प्राप्त करें और हटाएं) संचालन करें

निम्नलिखित स्रोत पर विचार करें (चलकर हम कम सरणी निर्माण वाक्य रचना का उपयोग कर रहे [] उपलब्ध संस्करण 5.4 के बाद से):

class UserCollection implements ArrayAccess {
    protected $_conn;
    
    protected $_requiredParams = ['username','password','email'];
    
    public function __construct() {
        $config = new Configuration();

        $connectionParams = [
            //your connection to the database
        ];
        
        $this->_conn = DriverManager::getConnection($connectionParams, $config);
    }
    
    protected function _getByUsername($username) {
        $ret = $this->_conn->executeQuery('SELECT * FROM `User` WHERE `username` IN (?)',
            [$username]
        )->fetch();
        
        return $ret;
    }
    
    // START of methods required by ArrayAccess interface
    public function offsetExists($offset) {
        return (bool) $this->_getByUsername($offset);
    }

    public function offsetGet($offset) {
        return $this->_getByUsername($offset);
    }

    public function offsetSet($offset, $value) {
        if (!is_array($value)) {
            throw new \Exception('value must be an Array');
        }

        $passed = array_intersect(array_values($this->_requiredParams), array_keys($value));
        if (count($passed) < count($this->_requiredParams)) {
            throw new \Exception('value must contain at least the following params: ' . implode(',', $this->_requiredParams));
        }
        $this->_conn->insert('User', $value);
    }

    public function offsetUnset($offset) {
        if (!is_string($offset)) {
            throw new \Exception('value must be the username to delete');
        }
        if (!$this->offsetGet($offset)) {
            throw new \Exception('user not found');
        }
        $this->_conn->delete('User', ['username' => $offset]);
    }
    // END of methods required by ArrayAccess interface
}

तब हम कर सकते हैं :

$users = new UserCollection();

var_dump(empty($users['testuser']),isset($users['testuser']));
$users['testuser'] = ['username' => 'testuser', 
                      'password' => 'testpassword',
                      'email'    => '[email protected]'];
var_dump(empty($users['testuser']), isset($users['testuser']), $users['testuser']);
unset($users['testuser']);
var_dump(empty($users['testuser']), isset($users['testuser']));

निम्नलिखित को आउटपुट करेगा, यह मानकर कि हमने कोड लॉन्च करने से पहले कोई testuser नहीं बनाया था:

bool(true)
bool(false)
bool(false)
bool(true)
array(17) {
  ["username"]=>
  string(8) "testuser"
  ["password"]=>
  string(12) "testpassword"
  ["email"]=>
  string(13) "[email protected]"
}
bool(true)
bool(false)

महत्वपूर्ण: जब आप array_key_exists फ़ंक्शन के साथ किसी कुंजी के अस्तित्व की जांच करते हैं, तो offsetExists को नहीं बुलाया जाता है। इसलिए निम्न कोड दो बार false आउटपुट देगा:

var_dump(array_key_exists('testuser', $users));
$users['testuser'] = ['username' => 'testuser', 
                      'password' => 'testpassword',
                      'email'    => '[email protected]'];
var_dump(array_key_exists('testuser', $users));

इटरेटर

के से कुछ कार्यों के साथ ऊपर से हमारी कक्षा का विस्तार करते हैं Iterator बार-बार दोहराना के साथ इस पर अनुमति देने के लिए इंटरफ़ेस foreach और while ।

सबसे पहले, हमें $_position हमारे वर्तमान सूचकांक को जोड़ने वाली एक संपत्ति जोड़ने की आवश्यकता है, आइए इसे $_position रूप में वर्ग गुणों में $_position :

// iterator current position, required by Iterator interface methods
protected $_position = 1;

दूसरा, Iterator इंटरफेस को हमारी कक्षा द्वारा कार्यान्वित किए जा रहे इंटरफेस की सूची में जोड़ें:

class UserCollection implements ArrayAccess, Iterator {

इसके बाद इंटरफ़ेस फ़ंक्शंस द्वारा आवश्यक जोड़ें:

// START of methods required by Iterator interface
public function current () {
    return $this->_getById($this->_position);
}
public function key () {
    return $this->_position;
}
public function next () {
    $this->_position++;
}
public function rewind () {
    $this->_position = 1;
}
public function valid () {
    return null !== $this->_getById($this->_position);
}
// END of methods required by Iterator interface

तो यहाँ सभी में दोनों इंटरफेस को लागू करने वाले वर्ग का पूरा स्रोत है। ध्यान दें कि यह उदाहरण सही नहीं है, क्योंकि डेटाबेस में आईडी अनुक्रमिक नहीं हो सकती है, लेकिन यह आपको मुख्य विचार देने के लिए लिखा गया था: आप ArrayAccess और Iterator इंटरफेस को लागू करके किसी भी संभव तरीके से अपने ऑब्जेक्ट संग्रह को संबोधित कर सकते हैं:

class UserCollection implements ArrayAccess, Iterator {
    // iterator current position, required by Iterator interface methods
    protected $_position = 1;
    
    // <add the old methods from the last code snippet here>
    
    // START of methods required by Iterator interface
    public function current () {
        return $this->_getById($this->_position);
    }
    public function key () {
        return $this->_position;
    }
    public function next () {
        $this->_position++;
    }
    public function rewind () {
        $this->_position = 1;
    }
    public function valid () {
        return null !== $this->_getById($this->_position);
    }
    // END of methods required by Iterator interface
}

और सभी उपयोगकर्ता वस्तुओं के माध्यम से एक फॉर्च्यूपिंग:

foreach ($users as $user) {
    var_dump($user['id']);
}

जो कुछ इस तरह का उत्पादन करेगा

string(2) "1"
string(2) "2"
string(2) "3"
string(2) "4"
...

चर की एक सरणी बनाना

$username = 'Hadibut';
$email = '[email protected]';

$variables = compact('username', 'email');
// $variables is now ['username' => 'Hadibut', 'email' => '[email protected]']

इस पद्धति का उपयोग अक्सर दो घटकों के बीच चर की एक सरणी को पास करने के लिए चौखटे में किया जाता है।