मैं अपने मैपिंग ऐरे में एक नया सेगमेंट (एक ही नाम के साथ) जोड़ना चाहता हूं, लेकिन एक अलग एलीमेंट के साथ लेकिन एक ही विधि


14

नीचे MapperInterface.php है

मैं यह पता लगाने की कोशिश कर रहा हूं कि कॉन्स्ट में एक और-कैसे स्टेटमेंट कैसे जोड़ा जाए। मानचित्रण सरणी। कुछ इस तरह:

if (LIN02 == VN”) 
o   Treat LIN03 as the SKU
·         else if (LIN04 == VN”) 
o   Treat LIN05 as the SKU

<?php

declare(strict_types=1);

namespace Direct\OrderUpdate\Api;

use Direct\OrderUpdate\Api\OrderUpdateInterface;

/**
 * Interface MapperInterface
 * Translates parsed edi file data to a \Direct\OrderUpdate\Api\OrderUpdateInterface
 * @package Direct\OrderUpdate\Api
 */
interface MapperInterface
{
    /**
     * Mapping array formatted as MAPPING[segemntId][elemntId] => methodNameToProcessTheValueOfElement
     * @var array
     */
    const MAPPING = [
        'DTM' => ['DTM02' => 'processCreatedAt'],   // shipment.created_at
        'PRF' => ['PRF01' => 'processIncrementId'], // order.increment_id
        'LIN' => ['LIN05' => 'processSku'],         // shipment.items.sku
        'SN1' => ['SN102' => 'processQty'],         // shipment.items.qty
        'REF' => ['REF02' => 'processTrack']        // shipment.tracks.track_number, shipment.tracks.carrier_code
    ];

    /**
     * Mapping for carrier codes
     * @var array
     */
    const CARRIER_CODES_MAPPING = ['FED' => 'fedex'];

    /**
     * @return array
     */
    public function getMapping(): array;

    /**
     * @param array $segments
     * @return OrderUpdateInterface
     */
    public function map(array $segments): OrderUpdateInterface;
}

मुझे उम्मीद है कि इसका कोई अर्थ है। यकीन नहीं होता कि इसके बारे में जाने का कोई बेहतर तरीका है लेकिन आखिरकार मुझे 1 "लिन" सेगमेंट की जरूरत है। शायद एक नया फ़ंक्शन जोड़ें और इस स्थिति का उपयोग करें?

नई फ़ाइल जवाब ***

    <?php

    declare(strict_types=1);

    namespace Direct\OrderUpdate\Api;

    use Direct\OrderUpdate\Api\OrderUpdateInterface;

    /**
     * Abstract Mapper
     * Translates parsed edi file data to a \Direct\OrderUpdate\Api\OrderUpdateInterface
     * @package Direct\OrderUpdate\Api
     */

    abstract class AbstractMapper{
    // Here we add all the methods from our interface as abstract
    public abstract function getMapping(): array;
    public abstract function map(array $segments): OrderUpdateInterface;

    // The const here will behave the same as in the interface
    const CARRIER_CODES_MAPPING = ['FED' => 'fedex'];

    // We will set our default mapping - notice these are private to disable access from outside
    private const MAPPING = ['LIN' => [
    'LIN02' => 'VN',
    'LIN01' => 'processSku'],
    'PRF' => ['PRF01' => 'processIncrementId'],
    'DTM' => ['DTM02' => 'processCreatedAt'],
    'SN1' => ['SN102' => 'processQty'],
    'REF' => ['REF02' => 'processTrack']];

    private $mapToProcess = [];

    // When we initiate this class we modify our $mapping member according to our new logic
    function __construct() {
    $this->mapToProcess = self::MAPPING; // init as
    if ($this->mapToProcess['LIN']['LIN02'] == 'VN')
    $this->mapToProcess['LIN']['LIN03'] = 'processSku';
    else if ($this->mapToProcess['LIN']['LIN04'] == 'VN')
        $this->mapToProcess['LIN']['LIN05'] = 'processSku';
    }

    // We use this method to get our process and don't directly use the map
    public function getProcess($segemntId, $elemntId) {
    return $this->mapToProcess[$segemntId][$elemntId];
    }

   }

class Obj extends AbstractMapper {
    // notice that as interface it need to implement all the abstract methods
    public function getMapping() : array {
        return [$this->getMapping()];
    }
    public function map() : array {
        return [$this->map()];
    }

}

class Obj extends AbstractMapper {
    // notice that as interface it need to implement all the abstract methods
    public function getMapping() : array {
        return [$this->getMapping()];
    }
    public function map() : array {
        return [$this->map()];
    }

}

तो आप चाहते हैं कि MAPPING कॉन्स्ट ऐरे डायनामिक हो? आप कांस्टेबल के साथ ऐसा नहीं कर सकते। आपको लगता है कि सरणी प्राप्त करने के लिए एक और समारोह का उपयोग करें और संशोधित यदि आवश्यक हो तो कर सकते हैं
dWinder

मैं वास्तव में नहीं जानता कि आप क्या करने की कोशिश कर रहे हैं। आपकी क्या प्राप्त करने की इच्छा है?
Stephan Vierkant

जवाबों:


6

जैसा कि आप यहाँ देख सकते हैं - const वैरिएबल लॉजिक को बदल या होल्ड नहीं कर सकता है । ध्यान दें कि इंटरफ़ेस तर्क को पकड़ नहीं सकता है - इसलिए आप अपने इंटरफ़ेस में ऐसा नहीं कर सकते।

मुझे लगता है कि आपके मुद्दे का बेहतर समाधान एक सार वर्ग का उपयोग करना है । मैं आपके इंटरफ़ेस के समान होगा (आप यहां विभिन्न के बारे में चर्चा देख सकते हैं लेकिन मुझे लगता है कि यह आपकी आवश्यकताओं के लिए समान होगा)

मैं इस तरह अमूर्त वर्ग बनाने की सिफारिश करूंगा:

abstract class AbstractMapper{
    // here add all the method from your interface as abstract
    public abstract function getMapping(): array;
    public abstract function map(array $segments): OrderUpdateInterface;

    // the const here will behave the same as in the interface
    const CARRIER_CODES_MAPPING = ['FED' => 'fedex'];

    // set your default mapping - notice those are private to disable access from outside
    private const MAPPING = ['LIN' => [
                                'LIN02' => 'NV', 
                                'LIN01' => 'processSku'], 
                             'PRF' => [
                                'PRF01' => 'processIncrementId']];
    private $mapToProcess = [];


    // when initiate this class modify your $mapping member according your logic
    function __construct() {
        $this->mapToProcess = self::MAPPING; // init as 
        if ($this->mapToProcess['LIN']['LIN02'] == 'NV')
            $this->mapToProcess['LIN']['LIN03'] = 'processSku';
        else if ($this->mapToProcess['LIN']['LIN04'] == 'NV')
            $this->mapToProcess['LIN']['LIN05'] = 'processSku';
     }

    // use method to get your process and don't use directly the map
    public function getProcess($segemntId, $elemntId) {
        return $this->mapToProcess[$segemntId][$elemntId];
    }

}

अब आप उस वस्तु को घोषित कर सकते हैं जो विरासत में मिली है:

class Obj extends AbstractMapper {
    // notice that as interface it need to implement all the abstract methods
    public function getMapping() : array {
        return [];
    }
}

उपयोग के लिए उदाहरण है:

$obj  = New Obj();
print_r($obj->getProcess('LIN', 'LIN01'));

ध्यान दें कि ऐसा लगता है कि आपका तर्क नहीं बदल रहा है इसलिए मैंने नया चर डाला और इसे निर्माण के दौरान सेट किया। यदि आप चाहते हैं कि आप इसे डंप कर सकते हैं और getProcessफ़ंक्शन के रिटर्न मान को संशोधित कर सकते हैं - तो वहां सभी तर्क रखें।

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

उम्मीद है की वो मदद करदे!


मुझे पिछले फ़ंक्शन सार्वजनिक फ़ंक्शन मैप (सरणी $ सेगमेंट) के ठीक नीचे अपनी पूरी फ़ाइल में उस पूरे सार वर्ग को एकीकृत / जोड़ने में सक्षम होना चाहिए: ऑर्डरअपडेटडेटटरफेस; } यहां
सिंगलटन

तो अब मैं बस सभी पुराने कोड को ओवरराइड कर सकता हूं और इस अमूर्त वर्ग का उपयोग कर सकता हूं? मैंने उत्तर को अपने मित्र के रूप में सही और बहुत उपयोगी बताया। @ डविंदर
सिंगलटन

हाँ तुम कर सकते हो। इंटरफ़ेस और अमूर्त वर्ग के बीच अंतर हैं लेकिन अधिकांश मामले के लिए यह एक ही कार्य करता है (आप पोस्ट की शुरुआत में लिंक में इसके बारे में पढ़ सकते हैं)।
dWinder

मुझे लगता है कि तर्क में मुझे अभी भी इस सही को जोड़ने की आवश्यकता है? और अगर ($ यह-> mapToProcess ['LIN'] ['LIN04'] == 'VN') $ यह-> mapToProcess ['LIN'] ['LIN05'] = 'processSku';
सिंगलटन

1
आपको उसे भी जोड़ना चाहिए। मैंने केवल इसका कुछ उदाहरण दिया है कि तर्क कहाँ होना चाहिए। मैं इसके साथ ही कोड को कवर करने के लिए इसे
संपादित करूंगा

5

आप निरंतर परिभाषा के अंदर एक और विवरण नहीं जोड़ सकते हैं। आप जो खोज रहे हैं, वह शायद यही है:

const A = 1;
const B = 2;

// Value of C is somewhat "more dynamic" and depends on values of other constants
const C = self::A == 1 ? self::A + self::B : 0;

// MAPPING array inherits "more dynamic" properties of C
const MAPPING = [
    self::A,
    self::B,
    self::C,
];

उत्पादन होगा:

0 => 1
1 => 2
2 => 3

दूसरे शब्दों में, आपको अलग-अलग स्थिरांक में अपने सरणी को तोड़ने की आवश्यकता होगी, फिर सभी सशर्त परिभाषित करें, फिर परिणामस्वरूप निरंतर मानों से अंतिम मैपिंग सरणी का निर्माण करें।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.