So vermeiden Sie die Neuordnung der gleichen Schlüssel bei der Verwendung von UKSSort

1. Einführung in die Funktion uksort ()

UKSORT (Array & $ Array, Callable $ Callback): Die BOOL -Funktion sortiert die Schlüssel eines Arrays. $ callback ist eine benutzerdefinierte Vergleichsfunktion, die zwei Schlüsselnamen als Parameter akzeptiert, Werte weniger als, gleich oder größer als Null zurückgibt und die Sortierreihenfolge bestimmt.

Beispielcode:

 $array = [
    'apple' => 1,
    'banana' => 2,
    'cherry' => 3,
];

uksort($array, function($a, $b) {
    return strcmp($a, $b);
});

print_r($array);

Ausgabe:

 Array
(
    [apple] => 1
    [banana] => 2
    [cherry] => 3
)

2. Problembeschreibung: Wiederholte Sortierung, die durch denselben Schlüssel verursacht wird

Wenn der Schlüssel eine Art Vorverarbeitungs- oder Zuordnungen durchlaufen hat, können verschiedene Originalschlüssel als "gleiche Schlüssel" angesehen werden. Zu diesem Zeitpunkt kann die Vergleichsfunktion häufig und wiederholt aufgerufen werden, was die Leistung beeinflusst. Zum Beispiel:

 $array = [
    'a_1' => 10,
    'a_2' => 20,
    'b_1' => 30,
];

uksort($array, function($key1, $key2) {
    // Vergleichen Sie nur den Teil vor der Untersteuerung
    $part1 = explode('_', $key1)[0];
    $part2 = explode('_', $key2)[0];
    return strcmp($part1, $part2);
});

Zu diesem Zeitpunkt werden 'a_1' und 'a_2' als "gleiche Schlüssel" behandelt, und die Vergleichsfunktion kann sie mehrmals vergleichen. Bei großen Arrays reduziert diese Wiederholung die Effizienz erheblich.

3. Die Kernidee, wiederholte Sortierung zu vermeiden

Um eine wiederholte Sortierung zu vermeiden, besteht der Schlüssel darin , wiederholte Berechnungen derselben "logischen Schlüssel" in der Vergleichsfunktion zu reduzieren und unnötige Vergleiche von äquivalenten Schlüssel zu vermeiden . Gemeinsame Praktiken sind:

1. Cache -Mapping -Ergebnisse : Die Vergleichsfunktion verwendet den statischen Cache intern, um eine wiederholte Berechnung der Schlüsselzuordnungswerte zu vermeiden.

2. Erstens, Vorverarbeitung und Deduplizierung der Schlüssel : Erstellen Sie eine Zuordnungstabelle, klassifizieren Sie die Schlüssel und vergleichen Sie sie direkt mit den Zuordnungsergebnissen beim Sortieren.

3. Verwenden Sie Hilfsarray -Sortierung : Verwenden Sie kartierte Werte als Hilfsschlüssel, um eine Reihe von zugeordneten Werten zu bilden, und verwenden Sie dann Array_Multisort () oder andere Sortierfunktionen, um wiederholte Anrufe zu vermeiden.

4. Spezifische Implementierungsbeispiele

Lösung 1: Vergleich von Cache -Karten innerhalb der Funktionen

 $array = [
    'a_1' => 10,
    'a_2' => 20,
    'b_1' => 30,
    'b_2' => 40,
    'c_1' => 50,
];

uksort($array, function($key1, $key2) {
    static $cache = [];

    if (!isset($cache[$key1])) {
        $cache[$key1] = explode('_', $key1)[0];
    }
    if (!isset($cache[$key2])) {
        $cache[$key2] = explode('_', $key2)[0];
    }

    return strcmp($cache[$key1], $cache[$key2]);
});

print_r($array);

Auf diese Weise wird die Operation Exploit ('_', $ Key) nur einmal durchgeführt, wodurch wiederholte Berechnungen vermieden und die Leistung verbessert wird.

Lösung 2: Vorverarbeitungskartierungsschlüssel, Unterstützung der Sortierung

 $array = [
    'a_1' => 10,
    'a_2' => 20,
    'b_1' => 30,
    'b_2' => 40,
    'c_1' => 50,
];

// Generieren Sie eine Reihe von Kartenschlüssel
$mappedKeys = [];
foreach (array_keys($array) as $key) {
    $mappedKeys[$key] = explode('_', $key)[0];
}

// Sortieren Sie die Schlüsselnamen, indem Sie den Schlüssel zuordnen
uasort($mappedKeys, function($a, $b) {
    return strcmp($a, $b);
});

// Rekonstruieren Sie das Hauptarray gemäß dem sortierten Mapping -Schlüssel
$newArray = [];
foreach ($mappedKeys as $originalKey => $_) {
    $newArray[$originalKey] = $array[$originalKey];
}

print_r($newArray);

Diese Lösung vermeidet mehrere Aufrufe, um Funktionen in UKSort zu vergleichen, und eignet sich für die Verwendung, wenn die Zuordnungsregeln komplex sind.

5. Zusammenfassung

• Bei der Verwendung von uksSort () wird die Vergleichsfunktion ein Vielfaches aufgerufen, insbesondere wenn die Tasten gleich konvertiert oder klassifiziert werden müssen, was anfällig für wiederholte Berechnungen ist.

• Durch die Verwendung von Caches in Vergleichsfunktionen oder Mapping -Tasten im Voraus kann wiederholte Sortierungen effektiv vermieden werden und die Leistung und Code -Klarheit kann verbessert werden.

• Welche die gewählte Lösung zu wählen ist, hängt von der Arraygröße, der Komplexität der Kartierungregel und der Leistungsanforderungen ab.

Nachdem Sie die oben genannten Fähigkeiten beherrschen, können Sie mit UKSSort () komplexe Schlüssel flexibler und effizienter sortieren.