type tools php Download - type tools php Quellcode-Download

PHP-Typ-Tools

Helfer für verschiedene Operationen mit PHP-Datentypen, Variablen und Containern.

So installieren Sie es in Ihrem Projekt

 composer require smoren/type-tools

Kurzreferenz

Einzigartiger Extraktor

Verfahren	Beschreibung	Codeausschnitt
`getString`	Gibt eine eindeutige Zeichenfolge der angegebenen Variablen zurück	`UniqueExtractor::getString($var, $strict)`
`getHash`	Gibt einen eindeutigen MD5-Hash-String der angegebenen Variablen zurück	`UniqueExtractor::getHash($var, $strict)`

Objekttyp-Caster

Verfahren	Beschreibung	Codeausschnitt
`cast`	Objekt in einen anderen relativen Typ umwandeln	`ObjectTypeCaster::cast($sourceObject, $destinationClass)`

Objektzugriff

Verfahren	Beschreibung	Codeausschnitt
`getPropertyValue`	Gibt den Wert der Objekteigenschaft zurück	`ObjectAccess::getPropertyValue($object, $propertyName)`
`setPropertyValue`	Legt den Wert der Objekteigenschaft fest	`ObjectAccess::setPropertyValue($object, $propertyName, $value)`
`hasReadableProperty`	Gibt „true“ zurück, wenn das Objekt eine lesbare Eigenschaft nach Name oder Getter hat	`ObjectAccess::hasReadableProperty($object, $propertyName)`
`hasWritableProperty`	Gibt „true“ zurück, wenn das Objekt über eine beschreibbare Eigenschaft nach Name oder Getter verfügt	`ObjectAccess::hasWritableProperty($object, $propertyName)`
`hasPublicProperty`	Gibt „true“ zurück, wenn das Objekt über eine öffentliche Eigenschaft verfügt	`ObjectAccess::hasPublicProperty($object, $propertyName)`
`hasPublicMethod`	Gibt „true“ zurück, wenn das Objekt eine öffentliche Methode hat	`ObjectAccess::hasPublicMethod($object, $methodName)`
`hasProperty`	Gibt „true“ zurück, wenn das Objekt eine Eigenschaft hat	`ObjectAccess::hasProperty($object, $propertyName)`
`hasMethod`	Gibt true zurück, wenn das Objekt eine Methode hat	`ObjectAccess::hasMethod($object, $methodName)`

Kartenzugriff

Verfahren	Beschreibung	Codeausschnitt
`get`	Gibt den Wert aus dem Container nach Schlüssel zurück	`MapAccess::get($container, $key, $defaultValue)`
`set`	Legt den Wert für den Container nach Schlüssel fest	`MapAccess::set($container, $key, $value)`
`exists`	Gibt true zurück, wenn im Container ein zugänglicher Schlüssel vorhanden ist	`MapAccess::exists($container, $key)`

Verwendung

Einzigartiger Extraktor

Tool zum Extrahieren eindeutiger IDs und Hashes beliebiger PHP-Variablen und Datenstrukturen.

Funktioniert in zwei Modi: streng und nicht streng.

Im strengen Modus:

Skalare: streng nach Typ eindeutig;
Objekte: einzigartig nach Instanz;
Arrays: eindeutig nach serialisiertem Wert;
Ressourcen: Das Ergebnis ist für jede Instanz eindeutig.

Im nicht strengen Modus:

Skalare: eindeutig nach Wert;
Objekte: eindeutig nach serialisiertem Wert;
Arrays: eindeutig nach serialisiertem Wert;
Ressourcen: Das Ergebnis ist je nach Instanz eindeutig.

String abrufen

Gibt eine eindeutige Zeichenfolge der angegebenen Variablen zurück.

UniqueExtractor::getString(mixed $var, bool $strict): string

 use Smoren  TypeTools  UniqueExtractor ;

$ intValue = 5 ;
$ floatValue = 5.0 ;

$ intValueStrictUniqueId = UniqueExtractor:: getString ( $ intValue , true );
$ floatValueStrictUniqueId = UniqueExtractor:: getString ( $ floatValue , true );

var_dump ( $ intValueStrictUniqueId === $ floatValueStrictUniqueId );
// false

$ intValueNonStrictUniqueId = UniqueExtractor:: getString ( $ intValue , false );
$ floatValueNonStrictUniqueId = UniqueExtractor:: getString ( $ floatValue , false );

var_dump ( $ intValueNonStrictUniqueId === $ floatValueNonStrictUniqueId );
// true

Holen Sie sich Hash

Gibt einen eindeutigen MD5-Hash-String der angegebenen Variablen zurück.

UniqueExtractor::getHash(mixed $var, bool $strict): string

 use Smoren  TypeTools  UniqueExtractor ;

$ intValue = 5 ;
$ floatValue = 5.0 ;

$ intValueStrictHash = UniqueExtractor:: getHash ( $ intValue , true );
$ floatValueStrictHash = UniqueExtractor:: getHash ( $ floatValue , true );

var_dump ( $ intValueStrictHash === $ floatValueStrictHash );
// false

$ intValueNonStrictHash = UniqueExtractor:: getHash ( $ intValue , false );
$ floatValueNonStrictHash = UniqueExtractor:: getHash ( $ floatValue , false );

var_dump ( $ intValueNonStrictHash === $ floatValueNonStrictHash );
// true

Objekttyp-Caster

Werkzeug zum Gießen verschiedener Objekttypen.

Gießen

Wandelt das Objekt in einen anderen relativen Typ um (Upcast oder Downcast).

ObjectTypeCaster::cast(object $sourceObject, string $destinationClass): mixed

 use Smoren  TypeTools  ObjectTypeCaster ;

class ParentClass
{
    public int $ a ;
    protected int $ b ;

    public function __construct ( int $ a , int $ b )
    {
        $ this -> a = $ a ;
        $ this -> b = $ b ;
    }

    public function toArray (): array
    {
        return [ $ this -> a , $ this -> b ];
    }
}

class ChildClass extends ParentClass
{
    private $ c = null ;

    public function __construct ( int $ a , int $ b , int $ c )
    {
        parent :: __construct ( $ a , $ b );
        $ this -> c = $ c ;
    }

    public function toArray (): array
    {
        return [ $ this -> a , $ this -> b , $ this -> c ];
    }
}

/* Downcast */

$ parentClassObject = new ParentClass ( 1 , 2 );
print_r ( $ parentClassObject -> toArray ());
// [1, 2]

$ castedToChildClass = ObjectTypeCaster:: cast ( $ parentClassObject , ChildClass::class);
print_r ( $ castedToChildClass -> toArray ());
// [1, 2, null]

var_dump ( get_class ( $ castedToChildClass ));
// ChildClass

/* Upcast */

$ childClassObject = new ChildClass ( 1 , 2 , 3 );
print_r ( $ childClassObject -> toArray ());
// [1, 2, 3]

$ castedToParentClass = ObjectTypeCaster:: cast ( $ childClassObject , ParentClass::class);
print_r ( $ castedToParentClass -> toArray ());
// [1, 2]

var_dump ( get_class ( $ castedToParentClass ));
// ParentClass

Objektzugriff

Werkzeug zum Reflektieren und Zugreifen auf Objekteigenschaften und -methoden.

Erhalten Sie den Immobilienwert

Gibt den Wert der Objekteigenschaft zurück.

ObjectAccess::getPropertyValue(object $object, string $propertyName): mixed

Kann über seinen Namen oder über den Getter auf die Eigenschaft zugreifen.

Löst SmorenTypeToolsExceptionsKeyError aus, wenn die Eigenschaft nicht lesbar ist.

 use Smoren  TypeTools  ObjectAccess ;

class MyClass {
    public int $ publicProperty = 1 ;
    private int $ privateProperty = 2 ;
    
    public function getPrivateProperty (): int
    {
        return $ this -> privateProperty ;
    }
}

$ myObject = new MyClass ();

// Getting by name:
var_dump (ObjectAccess:: getPropertyValue ( $ myObject , ' publicProperty ' ));
// 1

// Getting by getter (getPrivateProperty()):
var_dump (ObjectAccess:: getPropertyValue ( $ myObject , ' privateProperty ' ));
// 2

Eigenschaftswert festlegen

Legt den Wert der Objekteigenschaft fest.

ObjectAccess::setPropertyValue(object $object, string $propertyName, mixed $value): void

Kann über seinen Namen oder Setter auf die Eigenschaft zugreifen.

Löst SmorenTypeToolsExceptionsKeyError aus, wenn auf die Eigenschaft nicht zum Schreiben zugegriffen werden kann.

 use Smoren  TypeTools  ObjectAccess ;

class MyClass {
    public int $ publicProperty = 1 ;
    private int $ privateProperty = 2 ;
    
    public function setPrivateProperty ( int $ value ): void
    {
        $ this -> privateProperty = $ value ;
    }
    
    public function toArray (): array
    {
        return [ $ this -> publicProperty , $ this -> privateProperty ];
    }
}

$ myObject = new MyClass ();

// Setting by name:
ObjectAccess:: setPropertyValue ( $ myObject , ' publicProperty ' , 11 );

// Setting by setter (setPrivateProperty()):
ObjectAccess:: getPropertyValue ( $ myObject , ' privateProperty ' , 22 );

print_r ( $ myObject -> toArray ());
// [11, 22]

Hat lesbare Eigenschaft

Gibt „true“ zurück, wenn das Objekt eine Eigenschaft hat, die nach Name oder Getter lesbar ist.

ObjectAccess::hasReadableProperty(object $object, string $propertyName): bool

 use Smoren  TypeTools  ObjectAccess ;

class MyClass {
    public int $ publicProperty = 1 ;
    private int $ privateProperty = 2 ;
    private int $ notAccessibleProperty = 3 ;
    
    public function getPrivateProperty (): int
    {
        return $ this -> privateProperty ;
    }
}

$ myObject = new MyClass ();

// Accessible by name:
var_dump (ObjectAccess:: hasReadableProperty ( $ myObject , ' publicProperty ' ));
// true

// Accessible by getter:
var_dump (ObjectAccess:: hasReadableProperty ( $ myObject , ' privateProperty ' ));
// true

// Not accessible:
var_dump (ObjectAccess:: hasReadableProperty ( $ myObject , ' notAccessibleProperty ' ));
// false

Hat beschreibbare Eigenschaft

Gibt „true“ zurück, wenn das Objekt über eine Eigenschaft verfügt, die über den Namen oder den Setter beschreibbar ist.

ObjectAccess::hasWritableProperty(object $object, string $propertyName): bool

 use Smoren  TypeTools  ObjectAccess ;

class MyClass {
    public int $ publicProperty = 1 ;
    private int $ privateProperty = 2 ;
    private int $ notAccessibleProperty = 3 ;
    
    public function setPrivateProperty ( int $ value ): void
    {
        $ this -> privateProperty = $ value ;
    }
}

$ myObject = new MyClass ();

// Accessible by name:
var_dump (ObjectAccess:: hasWritableProperty ( $ myObject , ' publicProperty ' ));
// true

// Accessible by setter:
var_dump (ObjectAccess:: hasWritableProperty ( $ myObject , ' privateProperty ' ));
// true

// Not accessible:
var_dump (ObjectAccess:: hasWritableProperty ( $ myObject , ' notAccessibleProperty ' ));
// false

Hat öffentliches Eigentum

Gibt „true“ zurück, wenn das Objekt über eine öffentliche Eigenschaft verfügt.

ObjectAccess::hasPublicProperty(object $object, string $propertyName): bool

 use Smoren  TypeTools  ObjectAccess ;

class MyClass {
    public int $ publicProperty = 1 ;
    private int $ privateProperty = 2 ;
}

$ myObject = new MyClass ();

var_dump (ObjectAccess:: hasPublicProperty ( $ myObject , ' publicProperty ' ));
// true

var_dump (ObjectAccess:: hasPublicProperty ( $ myObject , ' privateProperty ' ));
// false

Hat eine öffentliche Methode

Gibt „true“ zurück, wenn das Objekt eine öffentliche Methode hat.

ObjectAccess::hasPublicMethod(object $object, string $methodName): bool

 use Smoren  TypeTools  ObjectAccess ;

class MyClass {
    public function publicMethod (): int
    {
        return 1 ;
    }
    
    private function privateMethod (): int
    {
        return 2 ;
    }
}

$ myObject = new MyClass ();

var_dump (ObjectAccess:: hasPublicMethod ( $ myObject , ' publicMethod ' ));
// true

var_dump (ObjectAccess:: hasPublicMethod ( $ myObject , ' privateMethod ' ));
// false

Hat Eigentum

Gibt „true“ zurück, wenn das Objekt eine Eigenschaft hat.

ObjectAccess::hasProperty(object $object, string $propertyName): bool

 use Smoren  TypeTools  ObjectAccess ;

class MyClass {
    public int $ publicProperty = 1 ;
    private int $ privateProperty = 2 ;
}

$ myObject = new MyClass ();

var_dump (ObjectAccess:: hasProperty ( $ myObject , ' publicProperty ' ));
// true

var_dump (ObjectAccess:: hasProperty ( $ myObject , ' privateProperty ' ));
// true

var_dump (ObjectAccess:: hasProperty ( $ myObject , ' anotherProperty ' ));
// false

Hat Methode

Gibt true zurück, wenn das Objekt eine Methode hat.

ObjectAccess::hasMethod(object $object, string $methodName): bool

 use Smoren  TypeTools  ObjectAccess ;

class MyClass {
    public function publicMethod (): int
    {
        return 1 ;
    }
    
    private function privateMethod (): int
    {
        return 2 ;
    }
}

$ myObject = new MyClass ();

var_dump (ObjectAccess:: hasMethod ( $ myObject , ' publicMethod ' ));
// true

var_dump (ObjectAccess:: hasMethod ( $ myObject , ' privateMethod ' ));
// true

Kartenzugriff

Tool zum kartenähnlichen Zugriff auf verschiedene Container über String-Schlüssel.

Kann zugreifen:

Eigenschaften von Objekten (nach Name oder Getter);
Elemente von Arrays und ArrayAccess-Objekten (nach Schlüssel).

Erhalten

Gibt einen Wert aus dem Container nach Schlüssel oder Standardwert zurück, wenn der Schlüssel nicht vorhanden oder nicht zugänglich ist.

Löst SmorenTypeToolsExceptionsKeyError aus, wenn der Schlüssel nicht lesbar ist.

MapAccess::get(mixed $container, string $key, mixed $defaultValue = null): mixed

 use Smoren  TypeTools  MapAccess ;

$ array = [
    ' a ' => 1 ,
];

var_dump (MapAccess:: get ( $ array , ' a ' , 0 ));
// 1

var_dump (MapAccess:: get ( $ array , ' b ' , 0 ));
// 0

var_dump (MapAccess:: get ( $ array , ' b ' ));
// null

class MyClass {
    public int $ publicProperty = 1 ;
    private int $ privateProperty = 2 ;
    private int $ notAccessibleProperty = 3 ;
    
    public function getPrivateProperty (): int
    {
        return $ this -> privateProperty ;
    }
}

$ myObject = new MyClass ();

// Accessible by name:
var_dump (MapAccess:: get ( $ myObject , ' publicProperty ' , 0 ));
// 1

// Accessible by getter:
var_dump (MapAccess:: get ( $ myObject , ' privateProperty ' ));
// 2

// Not accessible:
var_dump (MapAccess:: get ( $ myObject , ' notAccessibleProperty ' , - 1 ));
// -1

var_dump (MapAccess:: get ( $ myObject , ' notAccessibleProperty ' ));
// null

// Nonexistent:
var_dump (MapAccess:: get ( $ myObject , ' nonexistentProperty ' , - 1 ));
// -1

var_dump (MapAccess:: get ( $ myObject , ' nonexistentProperty ' ));
// null

Satz

Legt den Wert für den Container nach Schlüssel fest.

MapAccess::set(mixed $container, string $key, mixed $value): void

Löst SmorenTypeToolsExceptionsKeyError aus, wenn der Schlüssel nicht zum Schreiben zugänglich ist.

 use Smoren  TypeTools  MapAccess ;

$ array = [
    ' a ' => 1 ,
];

MapAccess:: set ( $ array , ' a ' , 11 );
MapAccess:: set ( $ array , ' b ' , 22 );

print_r ( $ array );
// ['a' => 11, 'b' => 22]

class MyClass {
    public int $ publicProperty = 1 ;
    private int $ privateProperty = 2 ;
    
    public function setPrivateProperty ( int $ value ): void
    {
        $ this -> privateProperty = $ value ;
    }
    
    public function toArray (): array
    {
        return [ $ this -> publicProperty , $ this -> privateProperty ];
    }
}

$ myObject = new MyClass ();

// Accessible by name:
MapAccess:: get ( $ myObject , ' publicProperty ' , 11 );

// Accessible by getter:
MapAccess:: get ( $ myObject , ' privateProperty ' , 22 );

print_r ( $ myObject -> toArray ());
// [11, 22]

Existiert

Gibt true zurück, wenn im Container ein zugänglicher Schlüssel vorhanden ist.

MapAccess::exists(mixed $container, string $key): bool

 use Smoren  TypeTools  MapAccess ;

$ array = [
    ' a ' => 1 ,
];

var_dump (MapAccess:: exists ( $ array , ' a ' ));
// true

var_dump (MapAccess:: exists ( $ array , ' b ' ));
// false
class MyClass {
    public int $ publicProperty = 1 ;
    private int $ privateProperty = 2 ;
    private int $ notAccessibleProperty = 3 ;
    
    public function getPrivateProperty (): int
    {
        return $ this -> privateProperty ;
    }
}

$ myObject = new MyClass ();

// Accessible by name:
var_dump (MapAccess:: exists ( $ myObject , ' publicProperty ' ));
// true

// Accessible by getter:
var_dump (MapAccess:: exists ( $ myObject , ' privateProperty ' ));
// true

// Not accessible:
var_dump (MapAccess:: get ( $ myObject , ' notAccessibleProperty ' ));
// false

// Nonexistent:
var_dump (MapAccess:: get ( $ myObject , ' nonexistentProperty ' , - 1 ));
// false

Unit-Tests

 composer install
composer test-init
composer test

Lizenz

PHP Type Tools ist unter der MIT-Lizenz lizenziert.

Expandieren