Trier le tableau d'objets par champs d'objet

Comment puis-je trier ce tableau d'objets par l'un de ses champs, comme nameou count?

  Array
(
    [0] => stdClass Object
        (
            [ID] => 1
            [name] => Mary Jane
            [count] => 420
        )

    [1] => stdClass Object
        (
            [ID] => 2
            [name] => Johnny
            [count] => 234
        )

    [2] => stdClass Object
        (
            [ID] => 3
            [name] => Kathy
            [count] => 4354
        )

   ....

Utilisez usort , voici un exemple adapté du manuel:

function cmp($a, $b) {
    return strcmp($a->name, $b->name);
}

usort($your_data, "cmp");

Vous pouvez également utiliser n'importe quel appelable comme deuxième argument. Voici quelques exemples:

• Utiliser des fonctions anonymes (à partir de PHP 5.3)

  usort($your_data, function($a, $b) {return strcmp($a->name, $b->name);});

• De l'intérieur d'une classe

  usort($your_data, array($this, "cmp")); // "cmp" should be a method in the class

• Utilisation des fonctions fléchées (depuis PHP 7.4)

  usort($your_data, fn($a, $b) => strcmp($a->name, $b->name));

De plus, si vous comparez des valeurs numériques, la fn($a, $b) => $a->count - $b->countfonction "comparer" devrait faire l'affaire.

Voici une meilleure façon d'utiliser les fermetures

usort($your_data, function($a, $b)
{
    return strcmp($a->name, $b->name);
});

Veuillez noter que ce n'est pas dans la documentation de PHP mais si vous utilisez 5.3+, les fermetures sont prises en charge là où des arguments appelables peuvent être fournis.

Si vous souhaitez trier les valeurs entières:

// Desc sort
usort($array,function($first,$second){
    return $first->number < $second->number;
});

// Asc sort
usort($array,function($first,$second){
    return $first->number > $second->number;
});

MISE À JOUR avec la chaîne n'oubliez pas de convertir dans le même registre (supérieur ou inférieur)

// Desc sort
usort($array,function($first,$second){
    return strtolower($first->text) < strtolower($second->text);
});

// Asc sort
usort($array,function($first,$second){
    return strtolower($first->text) > strtolower($second->text);
});

si vous utilisez php oop, vous devrez peut-être changer pour:

public static function cmp($a, $b) 
{
    return strcmp($a->name, $b->name);
}

//in this case FUNCTION_NAME would be cmp
usort($your_data, array('YOUR_CLASS_NAME','FUNCTION_NAME')); 

usort($array, 'my_sort_function');

var_dump($array);

function my_sort_function($a, $b)
{
    return $a->name < $b->name;
}

Le même code sera avec le countchamp.

Plus de détails sur usort: http://ru2.php.net/usort

Btw, d'où avez-vous obtenu ce tableau? J'espère que ce n'est pas de la base de données?

Vous pouvez utiliser cette fonction (fonctionne en version PHP> = 5.3):

function sortArrayByKey(&$array,$key,$string = false,$asc = true){
    if($string){
        usort($array,function ($a, $b) use(&$key,&$asc)
        {
            if($asc)    return strcmp(strtolower($a{$key}), strtolower($b{$key}));
            else        return strcmp(strtolower($b{$key}), strtolower($a{$key}));
        });
    }else{
        usort($array,function ($a, $b) use(&$key,&$asc)
        {
            if($a[$key] == $b{$key}){return 0;}
            if($asc) return ($a{$key} < $b{$key}) ? -1 : 1;
            else     return ($a{$key} > $b{$key}) ? -1 : 1;

        });
    }
}

Exemple:

sortArrayByKey($yourArray,"name",true); //String sort (ascending order)
sortArrayByKey($yourArray,"name",true,false); //String sort (descending order)
sortArrayByKey($yourArray,"id"); //number sort (ascending order)
sortArrayByKey($yourArray,"count",false,false); //number sort (descending order)

Vous pouvez utiliser usort, comme ceci:

usort($array,function($first,$second){
    return strcmp($first->name, $second->name);
});

Si tout échoue, voici une autre solution:

$names = array(); 
foreach ($my_array as $my_object) {
    $names[] = $my_object->name; //any object field
}

array_multisort($names, SORT_ASC, $my_array);

return $my_array;

L'inconvénient de toutes les réponses ici est qu'elles utilisent des noms de champs statiques , j'ai donc écrit une version ajustée dans le style OOP. En supposant que vous utilisez des méthodes getter, vous pouvez utiliser directement cette classe et utiliser le nom de champ comme paramètre . Quelqu'un le trouve probablement utile.

class CustomSort{

    public $field = '';

    public function cmp($a, $b)
    {
        /**
         * field for order is in a class variable $field
         * using getter function with naming convention getVariable() we set first letter to uppercase
         * we use variable variable names - $a->{'varName'} would directly access a field
         */
        return strcmp($a->{'get'.ucfirst($this->field)}(), $b->{'get'.ucfirst($this->field)}());
    }

    public function sortObjectArrayByField($array, $field)
    {
        $this->field = $field;
        usort($array, array("Your\Namespace\CustomSort", "cmp"));;
        return $array;
    }
} 

si vous voulez trier les dates

   usort($threads,function($first,$second){
        return strtotime($first->dateandtime) < strtotime($second->dateandtime);
    });

Une alternative simple qui vous permet de déterminer dynamiquement le champ sur lequel se base le tri:

$order_by = 'name';
usort($your_data, function ($a, $b) use ($order_by)
{
    return strcmp($a->{$order_by}, $b->{$order_by});
});

Ceci est basé sur la classe Closure , qui autorise les fonctions anonymes. Il est disponible depuis PHP 5.3.

Si vous avez besoin d'une comparaison de chaînes locale, vous pouvez utiliser à la strcollplace de strcmp.

N'oubliez pas d'utiliser d'abord setlocaleavec LC_COLLATEpour définir les informations locales si nécessaire.

  usort($your_data,function($a,$b){
    setlocale (LC_COLLATE, 'pl_PL.UTF-8'); // Example of Polish language collation
    return strcoll($a->name,$b->name);
  });

Si vous utilisez ceci dans Codeigniter, vous pouvez utiliser les méthodes:

usort($jobs, array($this->job_model, "sortJobs"));  // function inside Model
usort($jobs, array($this, "sortJobs")); // Written inside Controller.

@rmooney merci pour la suggestion. Ça m'aide vraiment.

Merci pour les inspirations, j'ai aussi dû ajouter un paramètre $ translator externe

usort($listable_products, function($a, $b) {
    global $translator;
    return strcmp($a->getFullTitle($translator), $b->getFullTitle($translator));
});

Si vous devez trier par un seul champ, usortc'est un bon choix. Cependant, la solution devient rapidement compliquée si vous devez trier par plusieurs champs. Dans ce cas, la bibliothèque YaLinqo * peut être utilisée, qui implémente une syntaxe de requête de type SQL pour les tableaux et les objets. Il a une jolie syntaxe pour tous les cas:

$sortedByName         = from($objects)->orderBy('$v->name');
$sortedByCount        = from($objects)->orderBy('$v->count');
$sortedByCountAndName = from($objects)->orderBy('$v->count')->thenBy('$v->name');

Voici '$v->count'un raccourci pour function ($v) { return $v->count; }(l'un ou l'autre peut être utilisé). Ces chaînes de méthodes renvoient des itérateurs, mais vous pouvez obtenir des tableaux en ajoutant ->toArray()à la fin si vous en avez besoin.

_{* développé par mes soins}

Vous pouvez utiliser la fonction triée de Nspl :

use function \nspl\a\sorted;
use function \nspl\op\propertyGetter;
use function \nspl\op\methodCaller;

// Sort by property value
$sortedByCount = sorted($objects, propertyGetter('count'));

// Or sort by result of method call
$sortedByName = sorted($objects, methodCaller('getName'));

C'est ce que j'ai pour une classe utilitaire

class Util
{
    public static function sortArrayByName(&$arrayToSort, $meta) {
        usort($arrayToSort, function($a, $b) use ($meta) {
            return strcmp($a[$meta], $b[$meta]);
        });
    }
}

Appeler:

Util::sortArrayByName($array, "array_property_name");

Vous pouvez utiliser usort comme ceci

Si vous souhaitez trier par numéro:

function cmp($a, $b)
{
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
}

$a = array(3, 2, 5, 6, 1);

usort($a, "cmp");

Ou Abc char:

function cmp($a, $b)
{
    return strcmp($a["fruit"], $b["fruit"]);
}

$fruits[0]["fruit"] = "lemons";
$fruits[1]["fruit"] = "apples";
$fruits[2]["fruit"] = "grapes";

usort($fruits, "cmp");

Voir plus: https://www.php.net/manual/en/function.usort.php