type tools php Télécharger - type tools php Téléchargement du code source

Outils de saisie PHP

Aides pour différentes opérations avec les types de données, variables et conteneurs PHP.

Comment installer sur votre projet

 composer require smoren/type-tools

Référence rapide

Extracteur unique

Méthode	Description	Extrait de code
`getString`	Renvoie la chaîne unique de la variable donnée	`UniqueExtractor::getString($var, $strict)`
`getHash`	Renvoie une chaîne de hachage md5 unique de la variable donnée	`UniqueExtractor::getHash($var, $strict)`

Type d'objet Roulette

Méthode	Description	Extrait de code
`cast`	Convertir un objet en un autre type relatif	`ObjectTypeCaster::cast($sourceObject, $destinationClass)`

Accès aux objets

Méthode	Description	Extrait de code
`getPropertyValue`	Renvoie la valeur de la propriété de l'objet	`ObjectAccess::getPropertyValue($object, $propertyName)`
`setPropertyValue`	Définit la valeur de la propriété de l'objet	`ObjectAccess::setPropertyValue($object, $propertyName, $value)`
`hasReadableProperty`	Renvoie vrai si l'objet a une propriété lisible par nom ou par getter	`ObjectAccess::hasReadableProperty($object, $propertyName)`
`hasWritableProperty`	Renvoie vrai si l'objet a une propriété inscriptible par nom ou par getter	`ObjectAccess::hasWritableProperty($object, $propertyName)`
`hasPublicProperty`	Renvoie vrai si l'objet a une propriété publique	`ObjectAccess::hasPublicProperty($object, $propertyName)`
`hasPublicMethod`	Renvoie vrai si l'objet a une méthode publique	`ObjectAccess::hasPublicMethod($object, $methodName)`
`hasProperty`	Renvoie vrai si l'objet a une propriété	`ObjectAccess::hasProperty($object, $propertyName)`
`hasMethod`	Renvoie vrai si l'objet a une méthode	`ObjectAccess::hasMethod($object, $methodName)`

Accès à la carte

Méthode	Description	Extrait de code
`get`	Renvoie la valeur du conteneur par clé	`MapAccess::get($container, $key, $defaultValue)`
`set`	Définit la valeur du conteneur par clé	`MapAccess::set($container, $key, $value)`
`exists`	Renvoie vrai si la clé accessible existe dans le conteneur	`MapAccess::exists($container, $key)`

Usage

Extracteur unique

Outil pour extraire des identifiants uniques et des hachages de toutes les variables et structures de données PHP.

Fonctionne en deux modes : strict et non strict.

En mode strict :

scalaires : uniques strictement par type ;
objets : uniques par instance ;
tableaux : uniques par valeur sérialisée ;
ressources : le résultat est unique par instance.

En mode non strict :

scalaires : uniques par valeur ;
objets : uniques par valeur sérialisée ;
tableaux : uniques par valeur sérialisée ;
ressources : le résultat est unique par instance.

Obtenir une chaîne

Renvoie la chaîne unique de la variable donnée.

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

Obtenez du hachage

Renvoie une chaîne de hachage md5 unique de la variable donnée.

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

Type d'objet Roulette

Outil pour lancer des types d'objets.

Casting

Convertir l'objet en un autre type relatif (upcast ou 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

Accès aux objets

Outil pour refléter et accéder aux propriétés et méthodes des objets.

Obtenir la valeur de la propriété

Renvoie la valeur de la propriété de l'objet.

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

Peut accéder à la propriété par son nom ou par getter.

Lance SmorenTypeToolsExceptionsKeyError si la propriété n'est pas accessible en lecture.

 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

Définir la valeur de la propriété

Définit la valeur de la propriété de l'objet.

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

Peut accéder à la propriété par son nom ou par passeur.

Lance SmorenTypeToolsExceptionsKeyError si la propriété n'est pas accessible en écriture.

 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]

A une propriété lisible

Renvoie vrai si l'objet a une propriété lisible par son nom ou par getter.

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

Possède une propriété inscriptible

Renvoie vrai si l'objet a une propriété accessible en écriture par nom ou par paramètre.

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

Possède une propriété publique

Renvoie vrai si l'objet a une propriété publique.

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

A une méthode publique

Renvoie vrai si l'objet a une méthode publique.

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

Possède une propriété

Renvoie vrai si l'objet a une propriété.

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

A une méthode

Renvoie vrai si l'objet a une méthode.

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

Accès à la carte

Outil permettant d'accéder de manière cartographique à différents conteneurs par des clés de chaîne.

Peut accéder :

propriétés des objets (par nom ou par getter) ;
éléments de tableaux et objets ArrayAccess (par clé).

Obtenir

Renvoie la valeur du conteneur par clé ou valeur par défaut si la clé n'existe pas ou n'est pas accessible.

Lance SmorenTypeToolsExceptionsKeyError si la clé n'est pas accessible en lecture.

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

Ensemble

Définit la valeur du conteneur par clé.

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

Lance SmorenTypeToolsExceptionsKeyError si la clé n'est pas accessible en écriture.

 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]

Existe

Renvoie vrai si la clé accessible existe dans le conteneur.

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

Tests unitaires

 composer install
composer test-init
composer test

Licence

PHP Type Tools est sous licence MIT.

Développer