नामित PHP वैकल्पिक तर्क?

Question

क्या कॉलिंग करते समय नामित वैकल्पिक पैरामीटर निर्दिष्ट करने के लिए PHP 4/5 में यह संभव है, जिन्हें आप निर्दिष्ट नहीं करना चाहते हैं (जैसे पायथन में)?

कुछ की तरह:

function foo($a,$b='', $c='') { 
    // whatever 
} 


foo("hello", $c="bar"); // we want $b as the default, but specify $c 

धन्यवाद

Answer 1

नहीं, यह संभव नहीं है: यदि आप तीसरे पैरामीटर को पास करना चाहते हैं, तो आपको दूसरा पास करना होगा। और नामित पैरामीटर या तो संभव नहीं हैं।

एक "समाधान" केवल एक पैरामीटर, एक सरणी का उपयोग करना होगा, और हमेशा इसे पास कर देगा ... लेकिन हमेशा इसमें सबकुछ परिभाषित न करें।

उदाहरण के लिए:

function foo($params) { 
    var_dump($params); 
} 

और यह इस तरह से बुला:

foo(array(
    'a' => 'hello', 
)); 

foo(array(
    'a' => 'hello', 
    'c' => 'glop', 
)); 

foo(array(
    'a' => 'hello', 
    'test' => 'another one', 
)); 

आप इस आउटपुट प्राप्त होगा:

array 
    'a' => string 'hello' (length=5) 

array 
    'a' => string 'hello' (length=5) 
    'c' => string 'glop' (length=4) 

array 
    'a' => string 'hello' (length=5) 
    'test' => string 'another one' (length=11) 

लेकिन मैं वास्तव में इस समाधान पसंद नहीं:

• आप phpdoc खो देंगे
• आपका आईडीई अब और किसी भी संकेत प्रदान करने के लिए ... कौन सा बुरा है

तो मैं बहुत ही विशेष मामलों में इस के साथ जाना चाहते हैं नहीं कर सकेंगे - कार्यों के लिए उदाहरण के लिए, कई विकल्पनल पैरामीटर के साथ ...

Answer 2

पीएचपी साथ

, बहस के क्रम क्या मायने रखती है। आप किसी विशेष तर्क को स्थान से बाहर निर्दिष्ट नहीं कर सकते हैं, लेकिन इसके बजाय, आप एक पूर्ण पास करके तर्क छोड़ सकते हैं, जब तक कि आप अपने फ़ंक्शन में मान को न मान मानें।

foo("hello", NULL, "bar"); 

Answer 3

नहीं, ऐसा नहीं है।

एकमात्र तरीका जो आप कुछ कर सकते हैं वह नामित कुंजी के साथ सरणी का उपयोग करके और क्या नहीं है।

Answer 4

यह बिल्कुल सुंदर नहीं है, लेकिन यह चाल है, कुछ कह सकते हैं।

class NamedArguments { 

    static function init($args) { 
     $assoc = reset($args); 
     if (is_array($assoc)) { 
      $diff = array_diff(array_keys($assoc), array_keys($args)); 
      if (empty($diff)) return $assoc; 
      trigger_error('Invalid parameters: '.join(',',$diff), E_USER_ERROR); 
     } 
     return array(); 
    } 

} 

class Test { 

    public static function foobar($required, $optional1 = '', $optional2 = '') { 
     extract(NamedArguments::init(get_defined_vars())); 
     printf("required: %s, optional1: %s, optional2: %s\n", $required, $optional1, $optional2); 
    } 

} 

Test::foobar("required", "optional1", "optional2"); 
Test::foobar(array(
    'required' => 'required', 
    'optional1' => 'optional1', 
    'optional2' => 'optional2' 
    )); 

Answer 5

यहां मैं जो उपयोग कर रहा हूं वह यहां है।

function func($arg, $options = Array()) { 
    $defaults = Array('foo' => 1.0, 
        'bar' => FALSE); 
    $options = array_merge($default, $options); 

    // Normal function body here. Use $options['foo'] and 
    // $options['bar'] to fetch named parameter values. 
    ... 
} 

आप आम तौर पर किसी भी नामित किया गया तर्क के बिना कॉल कर सकते हैं:

func("xyzzy") 

एक वैकल्पिक नामित तर्क निर्दिष्ट करने के लिए, यह वैकल्पिक में पारित एक समारोह परिभाषा जो वैकल्पिक नामित तर्क निर्दिष्ट करता है एक वैकल्पिक सरणी तर्क लेता सरणी:

func("xyzzy", Array('foo' => 5.7)) 

Answer 6

आप phpdoc और किसी सरणी के बजाय ऑब्जेक्ट को पास करके डिफ़ॉल्ट सेट करने की क्षमता रख सकते हैं, उदाहरण के लिए

function foo (FooOptions $opts) { 
    ... 
} 

बेशक

, आप FooOptions आपत्ति की स्थापना अतिरिक्त शब्दाडंबर के साथ उस के लिए भुगतान कर सकते हैं:

class FooOptions { 
    $opt1 = 'x'; 
    $opt2 = 'y'; 
    /* etc */ 
}; 

भी आप अपने समारोह कॉल में सख्त प्रकार की जाँच करते हैं, आप चाहते हैं देता है कि

। दुर्भाग्य से, पूरी तरह से मुक्त सवारी नहीं है।

Answer 7

नहीं, PHP नाम से तर्क पास नहीं कर सकता है।

आप एक समारोह है कि तर्क का एक बहुत लेता है और उन सभी को मूलभूत मूल्यों आप समारोह तर्क की एक सरणी के बजाय स्वीकार बनाने पर विचार कर सकते हैं हैं:

function test (array $args) { 
    $defaults = array('a' => '', 'b' => '', 'c' => ''); 
    $args = array_merge($defaults, array_intersect_key($args, $defaults)); 

    list($a, $b, $c) = array_values($args); 
    // an alternative to list(): extract($args); 

    // you can now use $a, $b, $c  
} 

See it in action।

Answer 8

वास्तव में नहीं। इसके कुछ विकल्प हैं जिनका आप उपयोग कर सकते हैं।

test(null,null,"hello") 

या एक सरणी पारित:

test(array('c' => "hello")); 

फिर, समारोह हो सकता है:

function test($array) { 
    $c = isset($array[c]) ? $array[c] : ''; 
} 

या बीच में एक समारोह जोड़ने के लिए, लेकिन मैं इस सुझाव नहीं होगा:

function ctest($c) { test('','',$c); } 

Answer 9

आज़माएं

$c

Answer 10

मुझे ऐसा लगता है ... आपको कॉल करने की जरूरत है न पहले & लाना, उदाहरण के लिए, substr समारोह, 3 पैरामीटर है, और करना चाहते सेट $ लंबाई के बिना $ शुरू करें, आपको ऐसा करने के लिए मजबूर किया जाएगा।

substr($str,0,10); 

इस ओवरराइड करने के लिए एक अच्छा तरीका हमेशा मापदंडों

Answer 11

सरल जवाब के लिए सरणियों उपयोग करने के लिए है। नहीं आप नहीं कर सकते
आप ऑब्जेक्ट/सरणी में गुजरकर या कुछ अन्य निर्भरता इंजेक्शन पैटर्न का उपयोग करके इसे प्राप्त करने का प्रयास कर सकते हैं।

function test ($a=null,$b=null,$c=null){ 
if (is_null($a) { 
    //do something about $a 
} 
if (is_null($b) { 
    //do something about $b 
} 
if (is_null($c) { 
    //do something about $c 
} 
} 

इस कॉल करने के लिए:

test(null,null,"Hello"); 

Answer 12

इसके अलावा, रिक्त स्ट्रिंग के बजाय nulls उपयोग करने के लिए के रूप में यह is_null()

जैसे का उपयोग कर अपने अस्तित्व के लिए परीक्षण करने के लिए और अधिक निश्चित है की कोशिश

बहुत कम, कभी-कभी हां, प्रतिबिंब और टाइप किए गए चर का उपयोग करके। हालांकि मुझे लगता है कि शायद यह नहीं है कि आप क्या कर रहे हैं।

आपकी समस्या का एक बेहतर समाधान के रूप में कार्य करता है याद आ रही एक अपने समारोह के अंदर अपने आप को

<?php 
    function test(array $params) 
    { 
    //Check for nulls etc etc 
    $a = $params['a']; 
    $b = $params['b']; 
    ...etc etc 
    } 

Answer 13

आप इसे अजगर रास्ता नहीं कर सकते संभाल 3 तर्क में पारित करने के लिए शायद है। Anway, आप एक साहचर्य सरणी गुजारें सकता और की तुलना में उनके नाम से सरणी प्रविष्टियों का उपयोग करें:

function test ($args=array('a'=>'','b'=>'','c'=>'')) 
{ 
    // do something 
} 

test(array('c'=>'Hello')); 

यह टाइपिंग को कम नहीं करता है, लेकिन कम से कम इसे और वर्णनात्मक है, तर्क के नाम दिखाई और में पठनीय होने कहते हैं।

Answer 14

आम तौर पर आप नहीं सोच सकते हैं लेकिन मुझे लगता है कि एक PHP फ़ंक्शन में नामित तर्कों को पारित करने के कई तरीके हैं। व्यक्तिगत तौर पर मैं सरणियों का उपयोग कर परिभाषा पर रिले और बस क्या मैं पास करनी होगी फोन:

class Test{ 
    public $a = false; 
    private $b = false; 
    public $c = false; 
    public $d = false; 
    public $e = false; 
    public function _factory(){ 
     $args = func_get_args(); 
     $args = $args[0]; 
     $this->a = array_key_exists("a",$args) ? $args["a"] : 0; 
     $this->b = array_key_exists("b",$args) ? $args["b"] : 0; 
     $this->c = array_key_exists("c",$args) ? $args["c"] : 0; 
     $this->d = array_key_exists("d",$args) ? $args["d"] : 0; 
     $this->e = array_key_exists("e",$args) ? $args["e"] : 0; 
    } 
    public function show(){ 
     var_dump($this); 
    } 
} 


$test = new Test(); 
$args["c"]=999; 
$test->_factory($args); 
$test->show(); 

लाइव यहाँ उदाहरण: http://sandbox.onlinephpfunctions.com/code/d7f27c6e504737482d396cbd6cdf1cc118e8c1ff

तो मेरे पास है 10 तर्क पारित करने के लिए, और उनमें से 3 डेटा मैं कर रहे हैं वास्तव में की तरह

return myfunction(false,false,10,false,false,"date",false,false,false,"desc"); 

दृष्टिकोण मैं रहा हूं साथ

समारोह कुछ में पारित करने के लिए, की जरूरत है नहीं भी स्मार्ट, आप सेटअप एक सरणी में 10 तर्क के किसी भी कर सकते हैं:

$arr['count']=10; 
$arr['type']="date"; 
$arr['order']="desc"; 
return myfunction($arr); 

मेरे पास इस ब्लॉग को अधिक जानकारी में इस प्रक्रिया को समझाते हुए एक पोस्ट है।

http://www.tbogard.com/2013/03/07/passing-named-arguments-to-a-function-in-php

Answer 15

पीएचपी 5.4 के रूप में आप आशुलिपि सारणी वाक्य-विन्यास (बोझिल "सरणी" के साथ सरणियों निर्दिष्ट करने के लिए और इसके बजाय का उपयोग "[]" nessecary नहीं) है।

आप नकल कई मायनों में नामित पैरामीटर, एक अच्छा और आसान तरीका हो सकता है कर सकते हैं:

function set_param_defaults($params) { 
    foreach($params['default_values'] as $arg_name => $arg_value) { 
    if (!isset($params[$arg_name])) { 
     $params[$arg_name] = $arg_value; 
    } 
    } 

    return $params; 
} 

function foo($z, $x = null, $y = null) { 
    $default_values = ['x' => 'default value for x', 'y' => 'default value for y']; 
    $params = set_param_defaults(get_defined_vars()); 

    print "$z\n"; 
    print $params['x'] . "\n"; 
    print $params['y'] . "\n"; 
} 

foo('set z value', null, 'set y value'); 
print "\n"; 
foo('set z value', 'set x value'); 

वैकल्पिक रूप से:: निजी तौर पर मैं

bar('one', ['a1' => 'two', 'bar' => 'three', 'foo' => 'four']); 
// output: twothreefour 

function bar ($a1, $kwargs = ['bar' => null, 'foo' => null]) { 
    extract($kwargs); 
    echo $a1; 
    echo $bar; 
    echo $foo; 
} 

Answer 16

यहाँ चारों ओर एक काम है इस विधि के साथ जाना होगा।

function foo($z, $x_y) { 
    $x_y += ['x' => 'default value for x', 'y' => 'default value for y']; 

    print "$z\n"; 
    print $x_y['x'] . "\n"; 
    print $x_y['y'] . "\n"; 
} 

foo('set z value', ['y' => 'set y value']); 
print "\n"; 
foo('set z value', ['x' => 'set x value']); 

दोनों उदाहरणों के लिए प्रिंट आउट आउट करें।

1 कॉल:

• सेट z मूल्य
• :
  • सेट z मूल्य
  • डिफ़ॉल्ट मान x
  • सेट y मूल्य

  2 कॉल के लिए से y

Answer 17

के लिए टी एक्स मूल्य

डिफ़ॉल्ट मान बस साहचर्य सरणी पैटर्न Drupal का उपयोग करता है का उपयोग करें। वैकल्पिक डिफ़ॉल्ट तर्कों के लिए, बस एक $options तर्क स्वीकार करें जो एक सहयोगी सरणी है। फिर सरणी में किसी भी गायब कुंजी सेट करने के लिए सरणी + ऑपरेटर का उपयोग करें।

function foo ($a_required_parameter, $options = array()) { 
    $options += array(
     'b' => '', 
     'c' => '', 
    ); 
    // whatever 
} 

foo('a', array('c' => 'c’s value')); // No need to pass b when specifying c. 

अपने कोड नमूने में वास्तव में