oop concatenare - Metodo PHP concatenamento?




stringhe variabili (8)

Ci sono 49 linee di codice che ti permettono di concatenare metodi su array come questo:

$fruits = new Arr(array("lemon", "orange", "banana", "apple"));
$fruits->change_key_case(CASE_UPPER)->filter()->walk(function($value,$key) {
     echo $key.': '.$value."\r\n";
});

Vedi questo articolo che mostra come concatenare tutte le settanta funzioni dell'array_ di PHP.

http://domexception.blogspot.fi/2013/08/php-magic-methods-and-arrayobject.html

Sto usando PHP 5 e ho sentito parlare di una nuova funzionalità nell'approccio orientato agli oggetti, chiamato "metodo di concatenamento". Cos'è esattamente? Come lo realizzo?


Un altro modo per concatenare il metodo statico:

class Maker 
{
    private static $result      = null;
    private static $delimiter   = '.';
    private static $data        = [];

    public static function words($words)
    {
        if( !empty($words) && count($words) )
        {
            foreach ($words as $w)
            {
                self::$data[] = $w;
            }
        }        
        return new static;
    }

    public static function concate($delimiter)
    {
        self::$delimiter = $delimiter;
        foreach (self::$data as $d)
        {
            self::$result .= $d.$delimiter;
        }
        return new static;
    }

    public static function get()
    {
        return rtrim(self::$result, self::$delimiter);
    }    
}

chiamata

echo Maker::words(['foo', 'bob', 'bar'])->concate('-')->get();

echo "<br />";

echo Maker::words(['foo', 'bob', 'bar'])->concate('>')->get();

class JobModel implements JobInterface{

        protected $job;

        public function __construct(Model $job){
            $this->job = $job;
        }

        public function find($id){
            return $this->job->find($id);
        }

        public function with($data=[]){
            $this->job = $this->job->with($params);
            return $this;
        }
}

class JobController{
    protected $job;

    public function __construct(JobModel $job){
        $this->job = $job;
    }

    public function index(){
        // chaining must be in order
        $this->job->with(['data'])->find(1);
    }
}

In realtà è piuttosto semplice, hai una serie di metodi di mutatore che restituiscono tutti gli oggetti originali (o altri), in questo modo puoi continuare a chiamare le funzioni.

<?php
class fakeString
{
    private $str;
    function __construct()
    {
        $this->str = "";
    }

    function addA()
    {
        $this->str .= "a";
        return $this;
    }

    function addB()
    {
        $this->str .= "b";
        return $this;
    }

    function getStr()
    {
        return $this->str;
    }
}


$a = new fakeString();


echo $a->addA()->addB()->getStr();

Questo produce "ab"


Fondamentalmente, prendi un oggetto:

$obj = new ObjectWithChainableMethods();

Chiama un metodo che effettivamente return $this; alla fine:

$obj->doSomething();

Poiché restituisce lo stesso oggetto, o meglio, un riferimento allo stesso oggetto, puoi continuare a chiamare i metodi della stessa classe sul valore restituito, in questo modo:

$obj->doSomething()->doSomethingElse();

Questo è tutto, davvero. Due cose importanti:

  1. Come si nota, è solo PHP 5. Non funzionerà correttamente in PHP 4 perché restituisce oggetti in base al valore e ciò significa che stai chiamando metodi su copie diverse di un oggetto, il che interromperà il tuo codice.

  2. Di nuovo, devi restituire l'oggetto nei tuoi metodi concatenabili:

    public function doSomething() {
        // Do stuff
        return $this;
    }
    
    public function doSomethingElse() {
        // Do more stuff
        return $this;
    }
    

Il concatenamento dei metodi significa che è possibile concatenare le chiamate ai metodi:

$object->method1()->method2()->method3()

Ciò significa che method1 () deve restituire un oggetto e method2 () riceve il risultato di method1 (). Method2 () passa quindi il valore restituito a method3 ().

Buon articolo: tutorial


Se intendi il metodo di concatenamento come in JavaScript (o alcune persone ricordano jQuery), perché non prendi semplicemente una libreria che porta tale sviluppo. esperienza in PHP? Ad esempio Extras - https://dsheiko.github.io/extras/ Questo estende i tipi PHP con JavaScript e metodi Underscore e fornisce il concatenamento:

Puoi concatenare un tipo particolare:

<?php
use \Dsheiko\Extras\Arrays;
// Chain of calls
$res = Arrays::chain([1, 2, 3])
    ->map(function($num){ return $num + 1; })
    ->filter(function($num){ return $num > 1; })
    ->reduce(function($carry, $num){ return $carry + $num; }, 0)
    ->value();

o

<?php
use \Dsheiko\Extras\Strings;
$res = Strings::from( " 12345 " )
            ->replace("/1/", "5")
            ->replace("/2/", "5")
            ->trim()
            ->substr(1, 3)
            ->get();
echo $res; // "534"

In alternativa puoi andare polimorfo:

<?php
use \Dsheiko\Extras\Any;

$res = Any::chain(new \ArrayObject([1,2,3]))
    ->toArray() // value is [1,2,3]
    ->map(function($num){ return [ "num" => $num ]; })
    // value is [[ "num" => 1, ..]]
    ->reduce(function($carry, $arr){
        $carry .= $arr["num"];
        return $carry;

    }, "") // value is "123"
    ->replace("/2/", "") // value is "13"
    ->then(function($value){
      if (empty($value)) {
        throw new \Exception("Empty value");
      }
      return $value;
    })
    ->value();
echo $res; // "13"

Pensiero corrente: gli hash dovrebbero essere il più lento disponibile, non il più veloce possibile. Questo sopprime gli attacchi dei tavoli arcobaleno .

Anche correlati, ma precauzionali: un utente malintenzionato non dovrebbe mai avere accesso illimitato alla schermata di accesso. Per evitare ciò: imposta una tabella di tracciamento degli indirizzi IP che registri ogni hit con l'URI. Se più di 5 tentativi di accesso provengono dallo stesso indirizzo IP in un periodo di cinque minuti, bloccare con una spiegazione. Un approccio secondario è quello di avere uno schema di password a due livelli, come fanno le banche. Mettere un blocco per i guasti al secondo passaggio aumenta la sicurezza.

Riepilogo: rallenta l'aggressore usando lunghe funzioni hash. Inoltre, blocca troppi accessi all'accesso e aggiungi un secondo livello di password.







php oop method-chaining