map
1.0.0
Gestion simple et élégante des tableaux PHP en utilisant un objet de collection de type tableau proposé par jQuery et Laravel Collections.
compositeur req aimeos/map
Versions PHP prises en charge :
PHP7.1+
PHP8+
Table des matières
Pourquoi PHP Map
Liste des méthodes
Créer
Accéder
Ajouter
Agrégat
Déboguer
Commande
Raccourcir
Test
Subir une mutation
Divers
Documentation
Méthodes personnalisées
Performance
Guide de mise à niveau
Au lieu de:
$list = [['id' => 'one', 'value' => 'value1'], ['id' => 'two', 'value' => 'value2'], null];$list[ ] = ['id' => 'trois', 'value' => 'value3']; // ajoute elementunset( $list[0] ); // supprime l'élément $list = array_filter( $list ); // supprime les valeurs vides ( $list ); // trier les éléments$pairs = array_column( $list, 'value', 'id' ); // créer ['trois' => 'valeur3']$value = reset( $pairs ) ?: null; // renvoie la première valeur
Utilisez uniquement :
$list = [['id' => 'one', 'value' => 'value1'], ['id' => 'two', 'value' => 'value2'], null];$value = map( $list ) // créer Map->push( ['id' => 'trois', 'value' => 'value3'] ) // ajouter un élément->supprimer( 0 ) // supprimer un élément->filtre () // supprime les valeurs vides->sort() // trie les éléments->col( 'value', 'id' ) // crée ['trois' => 'value3']->first(); // renvoie la première valeur
Vous pouvez toujours utiliser :
$map[] = ['id' => 'trois', 'value' => 'value3'];$value = $map[0];count( $map );foreach( $map as $key => valeur );
Utilisez les rappels :
De plus, l'objet map vous permet de passer des fonctions anonymes à de nombreuses méthodes, par exemple :
$map->each( function( $val, $key ) { echo $key . ': ' . $val;
} );Style jQuery :
Si vos éléments de carte sont des objets, vous pouvez appeler leurs méthodes pour chaque objet et obtenir le résultat sous forme de nouvelle carte, comme dans jQuery :
// MyClass implémente setStatus() (renvoyant $this) et getCode() (initialisé par le constructeur)$map = Map::from( ['a' => new MyClass( 'x' ), 'b' => new MyClass ( 'y' )] );$map->setStatus( 1 )->getCode()->toArray();
Cela appellera setStatus( 1 ) sur les deux objets. Si l'implémentation setStatus() renvoie $this , la nouvelle carte contiendra également :
['a' => MaClasse(), 'b' => MaClasse()]
Sur ces nouveaux éléments cartographiques, getCode() sera appelé et retournera x pour le premier objet et y pour le second. La carte créée à partir des résultats de getCode() retournera :
['a' => 'x', 'b' => 'y']
function map function is_map __call __callStatic __construct après tout arsort arsorted asort asorted at avg avant bool appel cast chunk clear clone col effondrement combiner comparer concat contient le nombre de copies countBy dd délimiteur diff diffAssoc diffKeys dump duplique chaque vide est égal à chaque sauf exploser le filtre trouver le premier firstKey flat flip float from fromJson get getIterator grep groupBy a if ifAny ifEmpty implémente dans l'index inclus insertAfter insertAt insertBefore inString int intersect intersectAssoc intersectKeys est isEmpty isNumeric isObject isScalar isString join jsonSerialize clés krsort krsorted ksort last lastKey ltrim map max merge méthode min aucun nième offsetExists offsetGet offsetSet offsetUnset uniquement ordre pad partition pourcentage tuyau pluck pop pos préfixe prépend pull push put aléatoire réduire rejeter la nouvelle clé supprimer remplacer inverser le tri inversé rsorted rtrim search sep set shift shuffle shuffled skip slice some sort sorted splice split strAfter strContains strContainsAll strEnds strEndsAll string strLower strReplace strStarts strStartsAll strUpper suffixe sum prendre les temps de frappe toArray toJson toReversed toSorted toUrl transformer transposer traverse tree trim uasort uasorted uksort uksorted union unique unshift usort les valeurs triées marchent où avec zip
function map() : Crée une nouvelle carte à partir des éléments passés
__construct() : Crée une nouvelle carte
clone() : Clone la carte et tous les objets qu'elle contient
copy() : Crée une nouvelle copie
éclater() : divise une chaîne en une carte d'éléments
from() : Crée une nouvelle carte à partir des éléments passés
fromJson() : Crée une nouvelle carte à partir d'une chaîne JSON
times() : Crée une nouvelle carte en appelant la fermeture plusieurs fois
tree() : Crée une arborescence à partir des éléments de la liste
__call() : Appelle une méthode personnalisée
__callStatic() : Appelle une méthode personnalisée de manière statique
all() : renvoie le tableau simple
at() : Renvoie la valeur à la position donnée
bool() : renvoie un élément par clé et le convertit en booléen
call() : Appelle la méthode donnée sur tous les éléments
find() : Renvoie le premier/dernier élément correspondant
first() : Renvoie le premier élément
firstKey() : Renvoie la première clé
get() : Renvoie un élément par clé
index() : Renvoie l'index numérique de la clé donnée
int() : renvoie un élément par clé et le convertit en entier
float() : renvoie un élément par clé et le convertit en float
key() : renvoie toutes les clés
last() : Renvoie le dernier élément
lastKey() : Renvoie la dernière clé
pop() : renvoie et supprime le dernier élément
pos() : Renvoie l'index numérique de la valeur
pull() : Renvoie et supprime un élément par clé
random() : Renvoie les éléments aléatoires en préservant les clés
search() : Trouver la clé d'un élément
shift() : renvoie et supprime le premier élément
string() : renvoie un élément par clé et le convertit en chaîne
toArray() : renvoie le tableau simple
unique() : Renvoie tous les éléments uniques en préservant les clés
valeurs() : renvoie tous les éléments avec de nouvelles clés
concat() : ajoute tous les éléments avec de nouvelles clés
insertAfter() : Insère la valeur après l'élément donné
insertAt() : Insère l'élément à la position donnée dans la carte
insertBefore() : Insère la valeur avant l'élément donné
merge() : Combine les éléments en écrasant ceux existants
pad() : Remplissez jusqu'à la longueur spécifiée avec la valeur donnée
prepend() : Ajoute un élément au début (alias)
push() : Ajoute un élément à la fin
put() : Définit la clé et la valeur données dans la carte (alias)
set() : écrase ou ajoute un élément
union() : ajoute les éléments sans écraser ceux existants
unshift() : Ajoute un élément au début
with() : renvoie une copie et définit un élément
avg() : renvoie la moyenne de toutes les valeurs
count() : Renvoie le nombre total d'éléments
countBy() : Compte la fréquence à laquelle les mêmes valeurs se trouvent sur la carte
max() : Renvoie la valeur maximale de tous les éléments
min() : Renvoie la valeur minimale de tous les éléments
pourcentage() : renvoie le pourcentage de tous les éléments ayant réussi le test
sum() : Renvoie la somme de toutes les valeurs de la carte
dd() : Imprime le contenu de la carte et termine le script
dump() : Imprime le contenu de la carte
tap() : transmet un clone de la carte au rappel donné
arsort() : éléments de tri inversés préservant les clés
arsorted() : Tri inverse des éléments préservant les clés dans une copie de la carte
asort() : Trie les éléments en préservant les clés
asorted() : Trie les éléments en préservant les clés dans une copie de la carte
krsort() : Trier inversé les éléments par clés
krsorted() : Tri inverse les éléments par clés dans une copie de la carte
ksort() : Trier les éléments par clés
order() : Ordonne les éléments en fonction des clés transmises
reverse() : Inverse l'ordre du tableau en préservant les clés
reversed() : Inverse l'ordre des éléments dans une copie de la carte
toReversed() : Inverse l'ordre des éléments dans une copie de la carte (alias)
rsort() : Tri inverse des éléments à l'aide de nouvelles clés
rsorted() : Tri inverse les éléments en utilisant de nouvelles clés dans une copie de la carte
shuffle() : randomise l'ordre des éléments
shuffled() : Randomise l'ordre des éléments dans une copie de la carte
sort() : trie les éléments sur place en attribuant de nouvelles clés
sorted() : Trie les éléments dans une copie de la carte en utilisant de nouvelles clés
toSorted() : Trie les éléments dans une copie de la carte en utilisant de nouvelles clés (alias)
uasort() : trie les éléments en préservant les clés à l'aide du rappel
uasorted() : trie les éléments en préservant les clés en utilisant le rappel dans une copie de la carte
uksort() : trie les éléments par clés à l'aide du rappel
uksorted() : trie les éléments par clés en utilisant le rappel dans une copie de la carte
usort() : trie les éléments en utilisant le rappel en attribuant de nouvelles clés
usorted() : trie les éléments en utilisant le rappel en attribuant de nouvelles clés dans une copie de la carte
after() : Renvoie les éléments après celui donné
before() : Renvoie les éléments précédant celui donné
clear() : Supprime tous les éléments
diff() : Renvoie les éléments manquants dans la liste donnée
diffAssoc() : Renvoie les éléments manquants dans la liste donnée et vérifie les clés
diffKeys() : Renvoie les éléments manquants dans la liste donnée par clés
except() : renvoie une nouvelle carte sans les clés d'élément transmises
filter() : Applique un filtre à tous les éléments
grep() : Applique une expression régulière à tous les éléments
intersect() : Renvoie les éléments partagés
intersectAssoc() : Renvoie les éléments partagés et vérifie les clés
intersectKeys() : Renvoie les éléments partagés par les clés
nth() : renvoie chaque nième élément de la carte
only() : renvoie uniquement les éléments spécifiés par les clés
pop() : renvoie et supprime le dernier élément
pull() : Renvoie et supprime un élément par clé
rejet() : supprime tous les éléments correspondants
remove() : Supprime un élément par clé
shift() : renvoie et supprime le premier élément
skip() : ignore le nombre d'éléments donné et renvoie le reste
slice() : Renvoie une tranche de la carte
take() : renvoie une nouvelle carte avec le nombre d'éléments donné
Where() : Filtre la liste des éléments selon une condition donnée
function is_map() : Teste si la variable est un objet map
compare() : Compare la valeur avec tous les éléments de la carte
contain() : Teste si un élément existe dans la carte
each() : applique un rappel à chaque élément
empty() : Teste si la carte est vide
equals() : Teste si le contenu de la carte est égal
each() : vérifie que tous les éléments réussissent le test du rappel donné
has() : Teste si une clé existe
if() : Exécute les rappels en fonction de la condition
ifAny() : Exécute des rappels si la carte contient des éléments
ifEmpty() : Exécute les rappels si la carte est vide
in() : Teste si l'élément est inclus
include() : Teste si l'élément est inclus
inString() : Teste si l'élément fait partie des chaînes de la carte
is() : Teste si la carte est constituée des mêmes clés et valeurs
isEmpty() : Teste si la carte est vide
isNumeric() : teste si toutes les entrées sont des valeurs numériques
isObject() : Teste si toutes les entrées sont des objets
isScalar() : Teste si toutes les entrées sont des valeurs scalaires.
isString() : Teste si toutes les entrées sont des valeurs de chaîne.
Implements() : Teste si toutes les entrées sont des objets implémentant l'interface
none() : Teste si aucun des éléments ne fait partie de la carte
some() : Teste si au moins un élément est inclus
strContains() : Teste si au moins une des chaînes transmises fait partie d'au moins une entrée
strContainsAll() : Teste si toutes les entrées contiennent l'une des chaînes transmises
strEnds() : Teste si au moins une des entrées se termine par l'une des chaînes passées
strEndsAll() : Teste si toutes les entrées se terminent par au moins une des chaînes transmises
strStarts() : Teste si au moins une des entrées commence par au moins une des chaînes transmises
strStartsAll() : Teste si toutes les entrées commencent par l'une des chaînes transmises
cast() : convertit toutes les entrées dans le type transmis
chunk() : divise la carte en morceaux
col() : Crée un mappage clé/valeur
effondrement() : Réduit les éléments multidimensionnels en écrasant les éléments
combiner() : Combine les éléments de la carte sous forme de clés avec les valeurs données
flat() : Aplatit les éléments multidimensionnels sans écraser les éléments
flip() : échange les clés avec leurs valeurs
groupBy() : regroupe les éléments ou objets du tableau associatif
join() : renvoie les éléments concaténés sous forme de chaîne avec séparateur
ltrim() : Supprime les caractères passés à gauche de toutes les chaînes
map() : applique un rappel à chaque élément et renvoie les résultats
partition() : divise la liste en nombre de groupes donné
pipe() : applique un rappel à toute la carte
pluck() : Crée un mappage clé/valeur (alias)
prefix() : Ajoute un préfixe à chaque entrée de carte
réduire() : calcule une valeur unique à partir du contenu de la carte
rekey() : Change les clés en fonction de la fonction passée
replace() : Remplace les éléments de manière récursive
rtrim() : Supprime les caractères passés à droite de toutes les chaînes
splice() : Remplace une tranche par de nouveaux éléments
strAfter() : Renvoie les chaînes après la valeur passée
strLower() : Convertit tous les caractères alphabétiques en minuscules
strReplace() : Remplace toutes les occurrences de la chaîne de recherche par la chaîne de remplacement
strUpper() : Convertit tous les caractères alphabétiques en majuscules
suffix() : Ajoute un suffixe à chaque entrée de carte
toJson() : Renvoie les éléments au format JSON
toUrl() : Crée une chaîne de requête HTTP
transfrom() : applique un rappel à chaque élément qui crée de nouvelles paires clé/valeur
transpose() : échange des lignes et des colonnes pour une carte bidimensionnelle
traverse() : Parcourt les arbres d'éléments imbriqués en passant chaque élément au rappel
trim() : Supprime les caractères passés à gauche/droite de toutes les chaînes
walk() : applique le rappel donné à tous les éléments
zip() : Fusionne les valeurs de tous les tableaux à l'index correspondant
delimiter() : Définit ou renvoie le séparateur des chemins vers les tableaux multidimensionnels
getIterator() : Renvoie un itérateur pour les éléments
jsonSerialize() : Spécifie les données qui doivent être sérialisées en JSON
method() : Enregistre une méthode personnalisée
offsetExists() : Vérifie si la clé existe
offsetGet() : Renvoie un élément par clé
offsetSet() : écrase un élément
offsetUnset() : Supprime un élément par clé
sep() : Définit le séparateur des chemins vers les tableaux multidimensionnels dans la carte actuelle
Teste si la variable est un objet cartographique
fonction is_map( $var ) : bool
@param variable $var mixte à tester
Exemples :
is_map( new Map() );// trueis_map( [] );// false
Renvoie une nouvelle carte pour les éléments passés.
carte de fonction( $elements = [] ) : AimeosMap
@param Mixed $elements Liste d'éléments ou valeur unique
@return AimeosMap Instance de carte
Exemples :
// arraymap( [] );// nullmap( null );// scalarmap( 'a' );// objectmap( new stdClass() );// map objectmap( new Map() );// iterable objectmap( new ArrayObject() );// fermeture évaluée lazilymap( function() {return [];
} );Voir aussi :
rekey() - Change les clés en fonction de la fonction passée
transform() - Crée de nouvelles paires clé/valeur en utilisant la fonction passée et renvoie une nouvelle carte pour le résultat
Crée un nouvel objet cartographique.
fonction publique __construct( $elements = [] )
@param Mixed $elements Élément unique, liste d'éléments, objet Map, objets itérables ou itérateurs, tout le reste
Exemples :
// arraynew Map( [] );// nullnew Map( null );// scalarnew Map( 'a' );// objectnew Map( new stdClass() );// map objectnew Map( new Map() ); // objet itérablenew Map( new ArrayObject() );// fermeture évaluée paresseusementnew Map( function() {return [];
} );Gère les appels dynamiques aux méthodes personnalisées pour la classe.
fonction publique __call( chaîne $name, tableau $params )
@param chaîne $name Nom de la méthode
@param array<mixed> $params Liste des paramètres
@return Mixed Résultat de la fonction appelée ou d'une nouvelle carte avec les résultats des méthodes d'élément
Appelle une méthode personnalisée ajoutée par Map::method(). La méthode appelée a accès au tableau interne en utilisant $this->items .
Exemples :
Map::method( 'case', function( $case = CASE_LOWER ) {return new self( array_change_key_case( $this->items, $case ) );
} );
Map::from( ['a' => 'bar'] )->case( CASE_UPPER );// ['A' => 'bar']Cela permet également d'appeler des méthodes objet si les éléments sont des objets :
$item = new MaClasse(); // avec la méthode setStatus() (renvoyant $this) et getCode() ImplementedMap::from( [$item, $item] )->setStatus( 1 )->getCode()->toArray();
Cela appellera la méthode setStatus() de chaque élément de la carte et utilisera leurs valeurs de retour pour créer une nouvelle carte. Sur la nouvelle carte, la méthode getCode() est appelée pour chaque élément et ses valeurs de retour sont également stockées dans une nouvelle carte. Cette dernière carte est ensuite renvoyée et les clés de carte de la carte d'origine sont conservées dans la carte renvoyée.
Si les éléments ne sont pas des objets, ils sont ignorés et si cela s'applique à tous les éléments, une carte vide est renvoyée. Si la carte contient des objets de types mixtes et que l'un d'entre eux n'implémente pas la méthode appelée, une erreur sera générée.
Gère les appels statiques aux méthodes personnalisées pour la classe.
fonction statique publique __callStatic (string $name, array $params)
@param chaîne $name Nom de la méthode
@param array<mixed> $params Liste des paramètres
@return Mixed Résultat de la fonction appelée ou d'une nouvelle carte avec les résultats des méthodes d'élément
@throws BadMethodCallException Si aucune méthode n'a été enregistrée pour ce nom
Appelle statiquement une méthode personnalisée ajoutée par Map::method(). La méthode appelée n'a pas accès au tableau interne car aucun objet n'est disponible.
Exemples :
Map::method( 'foo', function( $arg1, $arg2 ) {} );
Carte::foo( $arg1, $arg2 );Renvoie les éléments après celui donné.
fonction publique après( $value ) : self
@param Closure|int|string $value Valeur ou fonction avec paramètres (élément, clé)
@return self<int|string,mixed> Nouvelle carte avec les éléments après celui donné
Les clés sont conservées à l'aide de cette méthode.
Exemples :
Map::from( [0 => 'b', 1 => 'a'] )->after( 'b' );// [1 => 'a']Map::from( ['a' = > 1, 'b' => 0] )->after( 1 );// ['b' => 0]Map::from( [0 => 'b', 1 => 'a'] )->after( 'c' );// []Map::from( ['a', 'c', 'b'] )->after( function( $item, $key ) {return $item > = 'c';
} );// [2 => 'b']Renvoie les éléments sous forme de tableau simple.
fonction publique all() : tableau
@return array Tableau simple
Exemples :
Carte::from( ['a'] )->all();// ['a']
Trie tous les éléments dans l'ordre inverse et conserve l'association de clés.
fonction publique arsort( int $options = SORT_REGULAR ) : soi
@param int $options Options de tri pour arsort()
@return self<int|string,mixed> Carte mise à jour pour une interface fluide
Les clés sont conservées à l'aide de cette méthode et aucune nouvelle carte n'est créée.
Le paramètre $options modifie la façon dont les valeurs sont comparées. Les valeurs de paramètre possibles sont :
SORT_REGULAR : compare les éléments normalement (ne change pas de type)
SORT_NUMERIC : comparer les éléments numériquement
SORT_STRING : compare les éléments sous forme de chaînes
SORT_LOCALE_STRING : compare les éléments sous forme de chaînes, en fonction des paramètres régionaux actuels ou modifiés par setlocale()
SORT_NATURAL : compare les éléments sous forme de chaînes en utilisant "l'ordre naturel" comme natsort()
SORT_FLAG_CASE : utilisez SORT_STRING|SORT_FLAG_CASE et SORT_NATURAL|SORT_FLAG_CASE pour trier les chaînes sans tenir compte de la casse
Exemples :
Map::from( ['b' => 0, 'a' => 1] )->arsort();// ['a' => 1, 'b' => 0]Map::from( [ 'a', 'b'] )->arsort();// ['b', 'a']Map::from( [0 => 'C', 1 => 'b'] )->arsort();// [1 => 'b', 0 => 'C']Map::from( [0 => 'C', 1 => 'b'] )->arsort( SORT_STRING |SORT_FLAG_CASE );// [0 => 'C', 1 => 'b'] car 'C' -> 'c' et 'c' > 'b'
Trie une copie de tous les éléments dans l'ordre inverse et conserve l'association de clé.
fonction publique arsorted( int $options = SORT_REGULAR ) : self
@param int $options Options de tri pour arsort()
@return self<int|string,mixed> Carte mise à jour pour une interface fluide
Les clés sont conservées grâce à cette méthode et une nouvelle carte est créée.
Le paramètre $options modifie la façon dont les valeurs sont comparées. Les valeurs de paramètre possibles sont :
SORT_REGULAR : compare les éléments normalement (ne change pas de type)
SORT_NUMERIC : comparer les éléments numériquement
SORT_STRING : compare les éléments sous forme de chaînes
SORT_LOCALE_STRING : compare les éléments sous forme de chaînes, en fonction des paramètres régionaux actuels ou modifiés par setlocale()
SORT_NATURAL : compare les éléments sous forme de chaînes en utilisant "l'ordre naturel" comme natsort()
SORT_FLAG_CASE : utilisez SORT_STRING|SORT_FLAG_CASE et SORT_NATURAL|SORT_FLAG_CASE pour trier les chaînes sans tenir compte de la casse
Exemples :
Map::from( ['b' => 0, 'a' => 1] )->arsorted();// ['a' => 1, 'b' => 0]Map::from( [ 'a', 'b'] )->arsorted();// ['b', 'a']Map::from( [0 => 'C', 1 => 'b'] )->arsorted();// [1 => 'b', 0 => 'C']Map::from( [0 => 'C', 1 => 'b'] )->arsorted( SORT_STRING |SORT_FLAG_CASE );// [0 => 'C', 1 => 'b'] car 'C' -> 'c' et 'c' > 'b'
Trie tous les éléments et conserve l'association clé.
fonction publique asort( int $options = SORT_REGULAR ) : self
@param int $options Options de tri pour asort()
@return self<int|string,mixed> Carte mise à jour pour une interface fluide
Les clés sont conservées à l'aide de cette méthode et aucune nouvelle carte n'est créée.
Le paramètre modifie la façon dont les valeurs sont comparées. Les valeurs de paramètre possibles sont :
SORT_REGULAR : compare les éléments normalement (ne change pas de type)
SORT_NUMERIC : comparer les éléments numériquement
SORT_STRING : compare les éléments sous forme de chaînes
SORT_LOCALE_STRING : compare les éléments sous forme de chaînes, en fonction des paramètres régionaux actuels ou modifiés par setlocale()
SORT_NATURAL : compare les éléments sous forme de chaînes en utilisant "l'ordre naturel" comme natsort()
SORT_FLAG_CASE : utilisez SORT_STRING|SORT_FLAG_CASE et SORT_NATURAL|SORT_FLAG_CASE pour trier les chaînes sans tenir compte de la casse
Exemples :
Map::from( ['a' => 1, 'b' => 0] )->asort();// ['b' => 0, 'a' => 1]Map::from( [ 0 => 'b', 1 => 'a'] )->asort();// [1 => 'a', 0 => 'b']Map::from( [0 => 'C', 1 => 'b'] )->asort();// [0 => 'C', 1 => 'b'] car 'C' < 'b'Map::from( [0 => 'C', 1 => 'b'] )->arsort( SORT_STRING|SORT_FLAG_CASE );// [1 => 'b', 0 => 'C'] parce que 'C' -> 'c' et 'c' > 'b'
Trie une copie de tous les éléments et conserve l'association de clé.
fonction publique assortie (int $options = SORT_REGULAR) : self
@param int $options Options de tri pour asort()
@return self<int|string,mixed> Carte mise à jour pour une interface fluide
Les clés sont conservées grâce à cette méthode et une nouvelle carte est créée.
Le paramètre modifie la façon dont les valeurs sont comparées. Les valeurs de paramètre possibles sont :
SORT_REGULAR : compare les éléments normalement (ne change pas de type)
SORT_NUMERIC : comparer les éléments numériquement
SORT_STRING : compare les éléments sous forme de chaînes
SORT_LOCALE_STRING : compare les éléments sous forme de chaînes, en fonction des paramètres régionaux actuels ou modifiés par setlocale()
SORT_NATURAL : compare les éléments sous forme de chaînes en utilisant "l'ordre naturel" comme natsort()
SORT_FLAG_CASE : utilisez SORT_STRING|SORT_FLAG_CASE et SORT_NATURAL|SORT_FLAG_CASE pour trier les chaînes sans tenir compte de la casse
Exemples :
Map::from( ['a' => 1, 'b' => 0] )->asorted();// ['b' => 0, 'a' => 1]Map::from( [ 0 => 'b', 1 => 'a'] )->asorted();// [1 => 'a', 0 => 'b']Map::from( [0 => 'C', 1 => 'b'] )->asorted();// [0 => 'C', 1 => 'b'] car 'C' < 'b'Map::from( [0 => 'C', 1 => 'b'] )->asorted( SORT_STRING|SORT_FLAG_CASE );// [1 => 'b', 0 => 'C'] parce que 'C' -> 'c' et 'c' > 'b'
Renvoie la valeur à la position donnée.
fonction publique à (int $pos)
@param int $pos Position de la valeur dans la carte
@return Mixed�null Valeur à la position donnée ou NULL si aucune valeur n'est disponible
La position part de zéro et une position "0" renvoie le premier élément de la carte, "1" le deuxième et ainsi de suite. Si la position est négative, la séquence commencera à la fin de la carte.
Exemples :
Carte::from( [1, 3, 5] )->at( 0 );// 1Map::from( [1, 3, 5] )->at( 1 );// 3Map::from( [ 1, 3, 5] )->à( -1 );// 5Map::from( [1, 3, 5] )->à( 3 );// NULL
Renvoie la moyenne de toutes les valeurs entières et flottantes de la carte.
fonction publique avg( $col = null ) : float
@param Closure|string|null $col Fermeture, clé ou chemin d'accès aux valeurs du tableau ou de l'objet imbriqué pour calculer la moyenne
@return float Moyenne de tous les éléments ou 0 s'il n'y a aucun élément dans la carte
Les valeurs NULL sont traitées comme 0, les valeurs non numériques généreront une erreur.
Cela fonctionne également pour les tableaux multidimensionnels en passant les clés des tableaux séparées par le délimiteur ("/" par défaut), par exemple "key1/key2/key3" pour obtenir "val" de ['key1' => ['key2' => ['key3' => 'val']]] . Il en va de même pour les propriétés publiques des objets ou des objets implémentant les méthodes __isset() et __get() .
Exemples :
Map::from( [1, 3, 5] )->avg();// 3Map::from( [1, null, 5] )->avg();// 3Map::from( [1, 'sum', 5] )->avg();// 2Map::from( [['p' => 30], ['p' => 50], ['p' => 10]] )->avg( 'p' );// 30Map::from( [['i' => ['p' => 30]], ['<sp
