Classes de types de données personnalisées

Question

Je pense créer des types de données/prototypes personnalisés pour un projet mais je me demande si c'est une si bonne idée?

Par exemple

class String 
{ 
    var $Value; 
    private $escaped = false; 

    function __construct($String) 
    { 
     $this->Value = $String; 
    } 

    function escape() 
    { 
     if($escaped === false) 
     { 
      $this->Value = Registry::get('Database')->escape($this->Value); 
     } 
     return $this; 
    } 

    function trim() 
    { 
     $this->Value = trim($this->Value); 
     return $this; 
    } 

    function __toString() 
    { 
     return $this->__toString(); 
    } 
} 
$myValue = new String('Hello World')->trim()->escape(); 
//$myValue is now prepared for DB insert 

Il y aura des prototypes pour Array, Object, String, ressources etc ..

avec des tableaux, il mettra en œuvre Iterator et comme

Certains avantages que j'ai à l'esprit est des types de données spécifiques aux objets par exemple

interface Insert 
{ 
    public function Insert(String $Value); //Array/Object/Resource 
} 

Des prototypes personnalisés seraient utiles pour toutes les chaînes.

Mais pensez-vous que la quantité d'utilisation des ressources sera hors des avantages?

---

mis à jour pour POC

$String = new String('ValueText'); 

sprintf('Test %s',$String); //Works 

trim($String); //Works 

base64_encode($String); //Works 

également pour les tableaux de la bibliothèque SPL serait parfait.

class Array implements ArrayAccess, Iterator, Countable 
{ 
    public function __construct(){} 
    public function offsetSet($offset,$value){} 
    public function offsetExists($offset){} 
    public function offsetUnset($offset){} 
    public function offsetGet($offset){} 
    public function rewind(){} 
    public function current(){} 
    public function key(){} 
    public function next(){} 
    public function valid(){} 
    public function count(){} 
} 

---

Une autre idée serait les entités prorogeables

class DatabaseVariable extends String 
{ 
    function __construct($string) 
    { 
     parent::__constrcut($string); 
    } 

    public function escape() 
    { 
     //Blah 
    } 
} 

Avoir une nouvelle entité étendre un type de données, il sera héritera des méthodes disponibles pour ce type de données. Comme discuté à propos de l'autoboxing, c'est le système exact que je recherche mais comme il n'a pas encore été discuté, pour mon nouveau projet (Forum System) que j'ai commencé l'autre jour, pensez-vous que je devrais aller de l'avant et utiliser mon idée ?, l'utilisateur sera en mesure de faire des interactions plus rapides avec des types de données, et s'il y a une fonction qui ne prend pas en charge un objet passé, nous pouvons également faire

$RawResource = $Resourtce->Raw(); 

//... 

$Resource->Set($RawResource); 

Answer 1

à mon avis, le temps que vous passez écrire ce code, corriger ce code et maudire le fait que vous ne pouvez pas utiliser des centaines de fonctions PHP avec vos classes l'emportera sur tout avantage que ce code pourrait avoir.

De plus, le développeur qui hérite de votre projet vous détestera.

Answer 2

Cela semble beaucoup trop de problèmes pour ... apparemment pas de bénéfice.

Si vous craignez d'oublier d'échapper à des choses, arrêtez de tout échapper et commencez à utiliser des requêtes paramétrées.