array_reverse

Ordna elementen i matrisen i omvänd ordning.
Syntax:

Array array_reverse (array arr [, bool preserve_keys])

Funktionen array_reverse () returnerar en array vars element är i omvänd ordning i förhållande till matrisen som skickas i parametern. I det här fallet förloras inte förhållandet mellan nycklar och värden om den extra parametern preserve_keys = TRUE.

Ett exempel på att använda funktionen array_reverse ():

$ result = array_reverse ($ input);
$ result_keyed = array_reverse ($ input, true);
?>

Detta exempel kommer att göra både $ result och $ result_keyed arrays med samma värden, men olika nycklar. Utskriften av $ result och $ result_keyed arrays kommer att vara följande:

Array (
=> Array
=> grönt
=> röd
)

=> 4
=> php
Array (
=> Array
=> grönt
=> röd
)

=> 4
=> php
)

Obs! Den andra parametern preserve_keys lades till i PHP 4.0.3.

natcasesort

Utför en naturlig skiftlägeskänslig sortering på en array.
Syntax:

Ogiltig natcasesort (array arr)

Natcasesort () -funktionen sorterar arr-matrisen i en mänsklig-naturlig ordning och bevarar indexföreningar.
Denna funktion liknar natsort (), förutom att den inte är skiftlägeskänslig.
Ett exempel på att använda funktionen natcasesort ():

"img2.png", "img1.png", "IMG3.png");

sort ($ array1);

print_r ($ array1);

natcasesort ($ array2);
eko "nNaturlig sortering (skiftlägeskänslig) n";
print_r ($ array2);
?>

I exemplet ovan kommer följande ut:

Standard Sort Array (
=> IMG0.png
=> IMG3.png
=> img1.png
=> img10.png
=> img12.png
=> img2.png
)

Naturlig sortering (skiftlägeskänslig)
Array (
=> IMG0.png
=> img1.png
=> img2.png
=> IMG3.png
=> img10.png
=> img12.png
)

Funktionen stöds av PHP 4, PHP 5

Anpassad sortering av en associativ matris samtidigt som indexföreningar bevaras.
Syntax:

Bool usasort (array arr, function cmp_function)

Funktionen uasort () sorterar arr-arrayen som bevarar indexassociationer, med hjälp av den användardefinierade funktionen som anges av argumentet cmp_function för att jämföra elementindexen.
Denna funktion används huvudsakligen när matchning av index och värden för en array är avgörande.
Uasort () -funktionen returnerar true om sorteringen är framgångsrik och falsk annars.
Obs! Se funktionerna usort () och uksort () för att skriva en anpassad funktion.
Funktion som stöds av PHP 3> = 3.0.4, PHP 4, PHP 5

Anpassad sortering av en matris efter nycklar.
Syntax:

Bool uksort (array arr, function cmp_function)

Funktionen uksort () sorterar arr-arrayen efter index, bevarar indexassociationerna, med hjälp av den användardefinierade funktionen som anges i cmp_function-argumentet för att jämföra elementens index. Denna funktion skickas två jämförda index för elementen, och den måste returnera ett positivt eller negativt tal, eller 0.

Funktionen uksort () returnerar true om sorteringen lyckades och FALSE annars.
Ganska ofta måste vi sortera något efter mer komplexa kriterier än bara alfabetiskt. Anta till exempel att $ Files innehåller en lista med filnamn och underkataloger i den aktuella katalogen. Vi kanske vill skriva ut den här listan inte bara i lexografisk ordning, utan också så att alla kataloger kommer före filerna. I det här fallet bör vi använda funktionen uksort (), som tidigare har skrivit en jämförelse med två parametrar, som krävs av uksort ().

1 exempel på att använda funktionen uksort ():

// Denna funktion bör jämföra värdena för $ f1 och $ f2 och returnera:
// -1 om $ f1<$f2,
// 0 om $ f1 == $ f2
// 1 om $ f1> $ f2
// Under< и >vi förstår följande av dessa namn i utgångslistfunktionen FCmp ($ f1, $ f2)
(// Katalog går alltid före filen
om (is_dir ($ f1) &&! is_dir ($ f2)) returnerar -1;
// Filen kommer alltid efter katalogen
om (! is_dir ($ f1) && is_dir ($ f2)) returnerar 1;
// Jämför annars lexikografiskt
om ($ f1<$f2) return -1; elseif($f1>$ f2) retur 1; annars returnera 0;
}
// Låt $ Files innehålla en array med nycklar - filnamn
// i den aktuella katalogen. Låt oss sortera det .uksort ($ Files, "FCmp"); // skicka sorteringsfunktionen "

array_multisort ()

Sortera flera matriser eller flerdimensionella matriser (PHP 4, PHP 5)

Beskrivning:

Bool array_multisort (array ar1 [, blandad arg [, blandad ... [, array ...]]])

Array_multisort () -funktionen kan användas för att sortera flera matriser samtidigt eller en enda flerdimensionell array enligt en eller flera dimensioner. Denna funktion bevarar korrespondensen mellan nycklar och deras motsvarande värden.

Inmatningsrader behandlas som kolumner i en tabell som måste sorteras rad för rad - liknande beteendet för uttrycket SQL ORDER BY. Den första gruppen har företräde i sorteringsprocessen.

Strukturen för argumenten till denna funktion är lite ovanlig, men bekväm. Det första argumentet måste vara en array. Efterföljande argument kan antingen vara matriser eller sortera ordningsvärden, som visas i listan nedan.

Sorteringsordningsvärden:

SORT_ASC - sortera i stigande ordning
SORT_DESC - sortera i fallande ordning

Sortera typflaggor:

SORT_REGULAR - jämför artiklar på vanligt sätt
SORT_NUMERIC - jämför artiklar som om de vore siffror
SORT_STRING - jämför artiklar som om de vore strängar

Det är olagligt att ange två sorteringsflaggor av samma typ efter varje array. Sorteringsflaggorna som skickas efter ar1 -argumentet gäller endast det argumentet - innan funktionen börjar bearbeta nästa array återgår dessa flaggor till sina standardvärden SORT_ASC och SORT_REGULAR.

Sortera flera matriser

$ ar1 = array ("10", 100, 100, "a");
$ ar2 = array (1, 3, "2", 1);
array_multisort ($ ar1, $ ar2);

I exemplet ovan, efter att sorteringen är klar, kommer den första matrisen att innehålla 10, "a", 100, 100. Den andra - 1, 1, "2", 3. Element i den andra matrisen som motsvarar identiska element i först (100 och 100) kommer också att sorteras.

Sortera en flerdimensionell matris

$ ar = array (array ("10", 100, 100, "a"), array (1, 3, "2", 1));
array_multisort ($ ar, SORT_ASC, SORT_STRING,
$ ar, SORT_NUMERIC, SORT_DESC);

I exemplet ovan, efter sortering, kommer den första matrisen att innehålla 10, 100, 100, "a" (dess element sorterades i stigande ordning som om de var strängar), och den andra matrisen kommer att innehålla 1, 3, "2" , 1 (objekt sorteras som siffror, i fallande ordning).

Sortera en matris efter värde med hjälp av en anpassad jämförelsesfunktion (PHP 3> = 3.0.3, PHP 4, PHP 5)

Beskrivning:

Bool usort (array & array, callback cmp_function)

Denna funktion sorterar elementen i en array med hjälp av en anpassad funktion för att jämföra värden. Om du behöver sortera en matris efter ovanliga kriterier bör du använda den här funktionen.

Funktionen som används för jämförelse måste returnera ett heltal mindre än, lika med eller större än noll om det första argumentet är motsvarande mindre än, lika med eller större än det andra.

Obs! Om två element i den ursprungliga matrisen är lika är deras ordning i den sorterade matrisen odefinierad. Före PHP 4.0.6 bevarade användardefinierade funktioner ordningen på sådana element i den ursprungliga matrisen, men den nya sorteringsalgoritmen som introducerades i version 4.1.0 använder inte längre denna lösning och har ingen annan effektiv.

Returnerar SANT vid framgång eller FALSKT vid fel.

Usort () -exempel

funktion cmp ($ a, $ b)
{
om ($ a == $ b) (
returnera 0;
}
retur ($ a)

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

usort ($ a, "cmp");

while (list ($ key, $ value) = each ($ a)) (
echo "$ key: $ value
";
}
?>

0: 1
1: 2
2: 3
3: 5
4: 6

Kommentar: Uppenbarligen är sort () mer lämplig för detta triviala fall.

Ett exempel på att använda flerdimensionella matriser med funktionen usort ()

funktion cmp ($ a, $ b)
{
returstrcmp ($ a ["frukt"], $ b ["frukt"]);
}

$ fruits ["fruit"] = "citroner";
$ fruits ["fruit"] = "äpplen";
$ fruits ["fruit"] = "druvor";

usort ($ frukter, "cmp");

while (list ($ key, $ value) = each ($ fruits)) (
echo "\ $ fruits [$ key]:". $ value ["frukt"]. "
";
}
?>

Vid sortering av en flerdimensionell array innehåller variablerna $ a och $ b referenser till de två första indexen i matrisen.

Resultatet av detta exempel:

$ frukt: äpplen
$ frukter: vindruvor
$ frukter: citroner

Ett exempel på att använda usort () med en klassmetod

klass TestObj (
var $ namn;

funktion TestObj ($ namn)
{
$ this-> name = $ name;
}

/ * Detta är den statiska jämförelsefunktionen: * /
funktion cmp_obj ($ a, $ b)
{
$ al = strtolower ($ a-> namn);
$ bl = strtolower ($ b-> namn);
om ($ al == $ bl) (
returnera 0;
}
retur ($ al> $ bl)? +1: -1;
}
}

$ a = nytt TestObj ("c");
$ a = nytt TestObj ("b");
$ a = nytt TestObj ("d");

usort ($ a, array ("TestObj", "cmp_obj"));

för varje ($ a som $ artikel) (
echo $ item-> namn. "
";
}
?>

Resultatet av detta exempel:

B
c
d

Blandar matriselement.
Syntax:

Ogiltig blandning (array arr)

Shuffle () -funktionen blandar listan som skickades till den som den första arr -parametern så att dess värden fördelas slumpmässigt. I det här fallet ändras själva matrisen och associativa matriser uppfattas som listor.
Ett exempel på funktionen shuffle ():

$ nummer = intervall (1, 20);
srand ((float) mikrotid () * 1000000);
shuffle ($ -nummer);
while (list (, $ number) = each ($ numbers)) (
eko "$ number";
}

Obs! Från och med PHP 4.2.0 är det inte längre nödvändigt att initiera slumptalsgeneratorn med srand ()
eller mt_srand (), eftersom detta nu sker automatiskt.
Funktion som stöds av PHP 3> = 3.0.8, PHP 4, PHP 5

Sortera matrisen i stigande ordning.
Syntax:

Bool sort (array arr [, int sort_flags])

Sort () -funktionen är utformad för att sortera matriser i stigande ordning.
Obs! Denna funktion ändrar knapparna för de sorterade värdena. De där. alla associerade grupper behandlas av denna funktion som en lista. Efter beställning blir nyckelsekvensen till 0,1,2, ..., och värdena omfördelas efter behov. Som du kan se sparas inte länkarna mellan parametrarna key => värde, dessutom försvinner knapparna helt enkelt, så det är knappast lämpligt att sortera något annat än en lista.
Ett exempel på att använda funktionen sort ():

sortera ($ frukter);
reset ($ frukter);

eko "frukter [". $ nyckel. "] =". $ val. "n";
}
?>

Detta exempel kommer ut:

Frukter = äppelfrukter = bananfrukter = citronfrukter = apelsin

;
SORT_NUMERIC - jämför objekt med siffror;
SORT_STRING - Jämför objekt som strängar.

Sortera matrisen i fallande ordning.
Syntax:

Bool rsort (array array [, int sort_flags])

Funktionen rsort () sorterar matris i fallande ordning (högst till lägst).

Funktionen returnerar TRUE på framgång, FALSE annars.
Ett exempel på att använda funktionen rsort ():

rsort ($ frukter);
reset ($ frukter);
while (list ($ key, $ val) = each ($ fruits)) (
eko "$ key = $ valn";
}
?>

Detta exempel kommer ut:

0 = orange
1 = citron
2 = banan
3 = äpple

Sort_flags anger följande sorteringsflaggor:
SORT_REGULAR - jämför artiklar "som de är"
Funktionen stöds av PHP 3, PHP 4, PHP 5

Sortera en associativ matris i stigande ordning.
Syntax:

Bool asort (array arr [, int sort_flags])

Funktionen asort () sorterar matrisen som anges i dess parameter så att dess värden är i alfabetisk (om de är strängar) eller stigande (för siffror) ordning. Samtidigt bevaras förbindelserna mellan tangenterna och deras motsvarande värden, d.v.s. några key => värdepar bara "flyter" upp, och några - tvärtom "ner".

Funktionen returnerar true om den lyckas och false om ett fel uppstår.
Ett exempel på att använda funktionen asort ():

"citron", "a" => "apelsin", "b" => "banan", "c" => "äpple");
asort ($ frukter);
reset ($ frukter);
while (list ($ key, $ val) = each ($ fruits)) (
eko "$ key = $ valn";
}
?>

Exemplet kommer att mata ut följande:

C = appleb = bananad = lemona = apelsin

$ Fruits -gruppen har sorterats i stigande symbolisk ordning och arrayindexen har bevarats.



Funktionen stöds av PHP 3, PHP 4, PHP 5

Sortera den associativa matrisen i fallande ordning.
Syntax:

Bool arsort (array arr [, int sort_flags])

Arsort () -funktionen sorterar arr -matrisen i fallande ordning och bevarar indexföreningarna.
Denna funktion används huvudsakligen där ordningen på ett element i en matris är väsentlig.
Funktionen returnerar true om sorteringen lyckas och falsk om ett fel uppstår.
Ett exempel på att använda funktionen arsort ():

"citron", "a" => "apelsin", "b" => "banan", "c" => "äpple");
arsort ($ arr);
reset ($ arr);
while (list ($ key, $ val) = each ($ arr)) (
eko "$ key = $ vall";
}

Exemplet kommer ut:

A = apelsin = citronb = bananak = äpple

$ Arr -arrayen sorterades i fallande teckenordning, medan arrayindexen bevarades.
Sorteringsmetoden kan ändras med parametern sort_flags (tillval).
Denna parameter kan ange hur värden ska jämföras (som strängar eller som tal). Det kan ta följande fördefinierade värden:
SORT_REGULAR - normal jämförelse av värden;
SORT_NUMERIC - jämför som siffror;
SORT_STRING - jämför som strängar.
Denna parameter introducerades i PHP sedan version 4.
Funktionen stöds av PHP 3, PHP 4, PHP 5

Sortera matrisen i stigande ordning på nycklar.
Syntax:

Bool ksort (array arr [, int sort_flags])

Funktionen ksort () sorterar matrisen i stigande ordning på nycklar, och bevarar förhållandet mellan nycklarna och värdena. Den här funktionen är särskilt användbar vid sortering av associerade matriser.
Funktionen återgår till sant om allt var lyckat och falskt annars.
Ett exempel på att använda funktionen ksort ():

"citron", "a" => "apelsin", "b" => "banan", "c" => "äpple");
ksort ($ frukter);
reset ($ frukter);
while (list ($ key, $ val) = each ($ fruits)) (
eko "$ key = $ valn";
}
?>

Detta exempel kommer ut:

A = apelsin = bananak = äpplad = citron

Sort_flags anger följande sorteringsflaggor:
SORT_REGULAR - jämför artiklar "som de är"
SORT_NUMERIC - jämför objekt med siffror SORT_STRING - jämför objekt som strängar
Funktionen stöds av PHP 3, PHP 4, PHP 5

Sortera matrisen i fallande index.
Syntax:

Bool krsort (array arr [, int sort_flags])

Funktionen krsort () sorterar tangenterna i arr -matrisen i omvänd ordning. Samtidigt bevaras gänget med nycklar och värden. Den här funktionen är användbar vid sortering av associativa matriser.
Funktionen returnerar sant om det lyckas, och falskt annars.
Ett exempel på att använda funktionen krsort ():

"citron", "a" => "apelsin", "b" => "banan", "c" => "äpple");
krsort ($ frukt);
reset ($ frukter);
while (list ($ key, $ val) = each ($ fruits)) (
eko "$ key = $ valn";
}
?>

Detta exempel kommer ut:

D = citronc = appleb = banan = apelsin

Sort_flags anger följande sorteringsflaggor:
SORT_REGULAR - jämför artiklar "som de är"
SORT_NUMERIC - jämför objekt med siffror SORT_STRING - jämför objekt som strängar
Funktion som stöds av PHP 3> = 3.0.13, PHP 4, PHP 5

Utför "naturlig" sortering på en array.
Syntax:

Ogiltig natsort (array arr)

Natsort () -funktionen sorterar arr-matrisen i en mänsklig-naturlig ordning och bevarar indexföreningar.
Ett exempel på att använda funktionen natsort ():

sort ($ array1);
eko "Standard sortn";
print_r ($ array1);

natsort ($ array2);
eko "nNaturlig sortn";
print_r ($ array2);
?>

Det här exemplet ger följande:

Standard Sort Array (
=> img1.png
=> img10.png
=> img12.png
=> img2.png
)

Naturlig sort Array (
=> img1.png
=> img2.png
=> img10.png
=> img12.png
)

Funktionen stöds av PHP 4, PHP 5

Sortering är en av de viktigaste rutinerna när man arbetar med matriser. För att inse dess betydelse är det tillräckligt att komma ihåg sådana åtgärder som till exempel sortering av filmer i alfabetisk ordning eller sortering av priser i stigande eller fallande ordning, etc. Håller med, mycket vanliga åtgärder för olika applikationer! Idag kommer vi att prata om hur man sorterar arrayelement enligt specificerade förhållanden.

Så sortering gör det enklare att arbeta med matriser. När elementen är sorterade är det lättare att hitta dem och utföra nödvändiga åtgärder med dem, till exempel de som jag skrev om precis ovan. Allt beror på den uppgift du står inför.

Uppgifterna kan vara olika, men verktygen som vi kommer att använda kommer att förbli standard. Dessa verktyg är specialfunktioner som används för att sortera elementen i en array.

Det finns flera av dessa funktioner i php, och vilken som ska användas beror igen på den specifika uppgiften, liksom om din array är en associerande array eller en listmatris.

Låt oss ta ett exempel på dessa funktioner och se hur de fungerar.

Sortera matriser-listor i alfabetisk och omvänd ordning

Låt oss först bekanta oss med en ganska enkel och okomplicerad funktion. sortera ().

Det gör att vi kan sortera elementen i matrisen i stigande ordning eller, om dessa element är strängar, alfabetiskt.

Dess tillämpning är ganska enkel. För att testa den här funktionen behöver vi bara deklarera en array och sedan använda funktionen för att sortera dess element och visa resultatet på skärmen för att se vad som händer.

$ Mass = array ("Katya", "Anya", "Lena", "Andrey"); sort ($ Mass); print_r ($ Mass); ?>

Och resultatet blir följande. Som du kan se på skärmdumpen till höger sorteras objekten alfabetiskt. Om vi ​​har nummer i stället för strängelement, kommer den här funktionen också att sortera talen i stigande ordning. Du kan kontrollera det själv.

Det finns också en funktion som gör det motsatta, det vill säga den sorterar elementen i en array i fallande ordning eller i omvänd alfabetisk ordning.

Denna funktion kallas rsort ()... Det fungerar enligt följande:

$ Mass = array ("Katya", "Anya", "Lena", "Andrey"); rsort ($ Mass); print_r ($ Mass); ?>

Som ni ser är resultatet nu helt motsatt. Elementen i matrisen sorteras i fallande ordning, vilket i detta fall betyder i omvänd alfabetisk ordning.

Jag tror att med dessa funktioner är allt mycket tydligt. Testa dem med dina matriser så har du inga frågor.

Sortera associativa matriser

Allt är bra, men med associativa matriser kommer vi inte längre att kunna använda dessa funktioner, eftersom de bryter kopplingen mellan värdet och matrisnyckeln. Därför måste vi bekanta oss med några fler funktioner som gör att vi kan sortera associerade matriser.

Som vi vet har associativa matriser nycklar och värden. Därför kan sortering utföras med nycklar eller efter värden.

Låt oss börja med att sortera efter värde.

För att sortera värdena för en associativ matris alfabetiskt kommer vi att använda funktionen en sort ().

För att göra detta, skapa först en associerad array, tillämpa en funktion och visa resultatet på skärmen.

$ Mass ["one"] = "Katya"; $ Mass ["two"] = "Boris"; $ Mass ["three"] = "Anya"; $ Mass ["four"] = "Rita"; asort ($ Mass); print_r ($ Mass); ?>

Som du kan se sorteras värdena för den associativa matrisen alfabetiskt, men deras förhållande till nycklarna bevaras.

Det fungerar på samma sätt och funktionen arsort (), förutom att det sorterar värdena för den associativa gruppen i omvänd ordning.

$ Mass ["one"] = "Katya"; $ Mass ["two"] = "Boris"; $ Mass ["three"] = "Anya"; $ Mass ["four"] = "Rita"; arsort ($ Mass); print_r ($ Mass); ?>

Återigen kan vi se att värdena för arrayelementen behåller sin koppling till nycklarna, men sorteras i omvänd ordning.

Vi kan sortera samma associerade array med nycklar.

Som du säkert redan gissat kan detta göras i alfabetisk eller omvänd ordning.

För att kunna sortera en matris efter nycklar i alfabetisk ordning behöver vi funktionen ksort ().

$ Mass ["one"] = "Katya"; $ Mass ["two"] = "Boris"; $ Mass ["three"] = "Anya"; $ Mass ["four"] = "Rita"; ksort ($ Mass); print_r ($ Mass); ?>

Matrisen sorteras alfabetiskt efter tangenter.

För att sortera en matris med dess nycklar i omvänd ordning, använd funktionen krsort ().

$ Mass ["one"] = "Katya"; $ Mass ["two"] = "Boris"; $ Mass ["three"] = "Anya"; $ Mass ["four"] = "Rita"; krsort ($ Mass); print_r ($ Mass); ?>

Jag tror att allt är klart från skärmdumpen.

Anpassad sortering

Vi kan också ställa in vår egen sorteringsordning, det vill säga skapa en anpassad sortering.

För detta finns det också specialfunktioner i php.

För anpassad sortering av listor finns det en funktion usort ().

Det kommer att krävas två argument. Det första argumentet är vår array; det andra argumentet innehåller namnet på funktionen som jämför de två elementen.

Jämförelsesfunktionen accepterar två variabler och måste returnera ett av värdena:

1 - om det första jämförelseelementet är större än det andra;

-1 - om den andra är större än den första;

0 - om elementen är lika.

Således kan vi till exempel sortera elementen i en array i stigande ordning efter deras längd.

För att göra detta deklarerar vi först själva matrisen, som innehåller strängelement av olika längder.

Därefter använder vi den anpassade sorteringsfunktionen usort ()... Vi kommer att skicka det som argument: namnet på vår array och namnet på den funktion som vi skapade för att jämföra element.

Efter allt detta kan vi visa resultatet på skärmen för att se till att våra element sorteras i stigande ordning efter deras längd.

$ Mass = array ("Andrey", "Yana", "Katya"); funktion check_length ($ str1, $ str2) ($ length1 = strlen ($ str1); $ length2 = strlen ($ str2); if ($ length1 == $ length2): return 0; elseif ($ length1

Vi kommer att få följande resultat. Elementen i vårt sortiment sorteras i ökande längd.

Vi kan också göra en anpassad sortering av den associativa matrisen med dess nycklar. För detta behöver vi funktionen uksort () och själva associativa matrisen.

Låt oss lämna den anpassade funktionen densamma, det vill säga jämföra tangenternas längd.

Nycklarna till arrayelementen sorteras i stigande ordning efter deras längd.

Och vi kan också skapa en anpassad sortering av den associativa matrisen efter värdena på dess element. Funktionen hjälper oss med detta. uasort ().

Principen är fortfarande densamma.

$ Mass ["one"] = "yana"; $ Mass ["two"] = "andrey"; $ Mass ["three"] = "Katya"; funktion check_length ($ str1, $ str2) ($ length1 = strlen ($ str1); $ length2 = strlen ($ str2); if ($ length1 == $ length2): return 0; elseif ($ length1

Arrayen sorteras nu genom att öka längden på dess värden.

Naturligtvis kan den användardefinierade funktionen vara annorlunda, till exempel kan den kasta värden till det allmänna fallet eller göra något annat.

För att få en bra uppfattning om hur en anpassad sortering fungerar måste du träna och försöka skriva din egen jämförelsefunktion.

Men nu tror jag att du har en fullständig förståelse för hur du kan sortera elementen i en array och hur du använder dessa sorterade element.

Öva, skriv dina kommentarer och dela artikeln med dina vänner med knapparna på sociala medier.

Om du ännu inte har prenumererat på blogguppdateringar, prenumerera sedan. Prenumerationsformuläret finns nedan.

Anna Kotelnikova var med dig. Vi ses i följande artiklar.

Uppenbarligen kan det finnas ett behov av sortera en matris efter nyckelvärden... Till exempel om vi har array data om böcker, som i exemplet ovan, då är det troligt att vi kommer att vilja sortera böcker efter författarnamn. För att göra detta behöver PHP inte heller skriva många kodrader - du kan helt enkelt använda funktionen ksort () för sortering stigande (direkt order sortering) eller krsort ()- för sortering fallande (omvänd ordning sortering). Syntaxen för dessa funktioner liknar igen funktionens syntax sortera ().

$ books = array ("Pushkin" => "Ruslan och Lyudmila",

"Tolstoy" => "Krig och fred",

"Lermontov" => "En hjälte i vår tid");

// sortera matrisen,

// lagring av nyckelvärden

print_r ($ böcker);

Exempel 7.9. Sortera en matris efter nycklar (html , Text )

Array ([Lermontov] => Vår tids hjälte

[Pushkin] => Ruslan och Lyudmila

[Tolstoy] => Krig och fred)

Sortering med en användardefinierad funktion

Förutom två enkla sätt sortera matrisvärden(fallande eller stigande) PHP erbjuder användaren möjlighet att ställa in kriterierna för sortering data. Kriteriet ställs in med en funktion vars namn anges som argument för specialfunktioner sorteringusort () eller uksort ()... Av namnen på dessa funktioner kan du gissa det usort ()sorterarmenande element array, a uksort ()–menandematrisnycklar med en användardefinierad funktion. Båda funktionerna återkommer om sortering framgångsrik och falsk annars. Deras syntax är följande:

usort (array -sorteringsfunktion)

uksort (array, sorteringsfunktion)

Självklart inte sortera array använder någon anpassad funktion. Denna funktion måste uppfylla vissa kriterier för att kunna jämföra artiklar array... Hur ska en sorteringsfunktion ordnas? Först måste den ha två argument. I dem kommer tolken att överföra par värden element för funktion usort () eller matrisnycklar för funktion uksort ()... För det andra måste sorteringsfunktionen returnera:

ett heltal mindre än noll om det första argumentet är mindre än det andra;

ett tal lika med noll om de två argumenten är lika;

ett tal större än noll om det första argumentet är större än det andra.

När det gäller andra funktioner sortering, för funktionen usort () det finns en analog som inte ändras menandenycklar, - funktion uasort ().

Exempel 7.10. Låt oss säga att vi har array innehållande sådan information om litterära verk som titel, författare och skapelseår. Vi vill sortera böckerna efter skapelsedatum.

// arrayen ser ut så här:

$ books = array ("En hjälte i vår tid" =>

array ("Lermontov", 1840),

"Ruslan och Lyudmila" => array ("Pushkin", 1820),

"War and Peace" => array ("Tolstoy", 1863),

"Idiot" => array ("Dostojevskij", 1868));

/ * du kan naturligtvis skriva om den här matrisen

annorlunda genom att göra publiceringsåret, till exempel

index, men det är mycket mer bekvämt att skriva ditt eget

funktion för sortering * /

uasort ($ böcker, "cmp");

// sortera matrisen med cmp -funktionen

foreach ($ böcker som $ key => $ book) (

eko "$ book: \" $ key \ "
";

funktion cmp ($ a, $ b) (

// funktion som definierar sorteringsmetoden

om ($ a< $b) return -1;

elseif ($ a == $ b) return 0;

Exempel 7.10. Sortera med anpassade funktioner (html , Text )

Som ett resultat får vi:

Pushkin: "Ruslan och Lyudmila"

Lermontov: "En hjälte i vår tid"

Tolstoy: "Krig och fred"

Dostojevskij: "Idioten"

Vi har tillämpat vår egen funktion sortering till alla element array... Tänk sedan på hur tillämpa någon annan anpassad funktion på arrayelement.

Tillämpa en funktion på alla element i en array

Fungera array_walk (array, function [, data]) tillämpar en användarskapad funktion på alla element array en array och returnerar true om operationen är framgångsrik och falsk annars.

En anpassad funktion har vanligtvis två argument som skickas omväxlande menande och nyckel- varje element array... Men om när du ringer till funktionen array_walk () det tredje argumentet anges, kommer det att behandlas som menande det tredje argumentet för den användardefinierade funktionen, vars betydelse bestäms av användaren själv. Om användarfunktionen kräver fler argument än det skickas till det, då för varje samtal array_walk () en varning kommer att utfärdas.

Om du behöver arbeta med riktiga värden array, och inte med deras kopior, bör du skicka argumentet till funktionen genom referens. Tänk dock på att du inte kan lägga till eller ta bort objekt. array och utföra handlingar som förändrar sig själv array, eftersom i detta fall resultatet av arbetet array_walk () anses vara odefinierad.

$ books1 = array (

"AS Pushkin" => "Ruslan och Lyudmila",

"Leo Tolstoy" => "Krig och fred",

"M.Yu. Lermontov" => "En hjälte i vår tid");

funktion try_walk ($ val, $ key, $ data) (

echo "$ data \" $ val \ "skrev $ key
";

// $ book1 try_walk -funktion

array_walk ($ books1, "try_walk", "Roman");

Exempel 7.11. Tillämpa en funktion på alla element i matrisen (html , Text )

Romanen "Ruslan och Lyudmila" skrevs av A.S. Pushkin

Romanen "Krig och fred" skrevs av L.N. Tolstoj

Romanen "En hjälte i vår tid"

skriven av M.Yu. Lermontov

Observera att vi inte har ändrats värden elementen array... För att ändra dem var det nödvändigt att överföra menande till $ var -variabeln i try_walk -funktionen genom referens.

$ books1 = array (

"AS Pushkin" => "Ruslan och Lyudmila",

"Leo Tolstoy" => "Krig och fred",

"M.Yu. Lermontov" => "En hjälte i vår tid");

// skapa den funktion vi vill ha

// gäller för matriselement

funktion try_walk (& $ val, $ key) (

$ key = "

$ val = "Namn: \" ". $ val." \ "

// gäller alla element i matrisen

// $ book1 try_walk -funktion

array_walk ($ books1, "try_walk");

print_r ($ books1);

Exempel 7.12. Tillämpa funktionen på alla element i matrisen. Alternativ 2 (html , Text )

Som ett resultat av manusets arbete får vi:

Titel: "Ruslan och Lyudmila"

Titel: "Krig och fred"

Titel: "En hjälte i vår tid"

Array ([A. Pushkin] =>

Titel: "Ruslan och Lyudmila"

[L.N. Tolstoy] =>

Titel: "Krig och fred"

[M.Yu. Lermontov] =>

Titel: "En hjälte i vår tid")

Och prata med dig om de olika "godsakerna" som du kan behöva när du slutför färdiga lösningar.

Och en av dem, som jag personligen måste träffa ganska ofta på jobbet, är sortera en matrisphp.

Sådana frekventa möten berodde på att människor, som praktiken visar, ibland gillar att, för en ändring, ändra sekvensen för att visa objekt på sin webbplats - vare sig det är produkter i en webbutik, användarinlägg på forumet eller informationsblock på visitkortsajter.

För nybörjare kommer jag bara att påminna dig om de viktigaste bestämmelserna på det mest begripliga språket. Därför, om du inte anser dig själv vara en sådan, kan du gå direkt till exemplen på uppgifter och sätt att lösa dem.

Lite teori om php -matriser

PHP är ett programmeringsspråk på serversidan. Server-sida, eftersom skript som körs av användare via ett webbgränssnitt (webbläsare) lagras och körs på servern.

PHP -skript är dolda för den genomsnittliga användarens syn. I fönstret i dina webbläsare ser du bara resultaten av deras körning.

En matris i programmering är en samling av vissa data. De består av arrayelement, som är par [index] => [värde].

Arrays kan vara statiska, dynamiska, heterogena etc. (en hel vetenskap) 🙂 För oss att arbeta med dem är klassificeringen i endimensionell och flerdimensionell tillräckligt.

För att du ska förstå skillnaden mellan dem räcker det med att beskriva deras struktur.

Endimensionell php-array:

Array (=> 1 => 2 => 3)

Php flerdimensionell array:

Array (=> Array (=> 1) => Array (=> 2) => Array (=> 3))

Har du märkt? Om inte, var uppmärksam på elementen i den flerdimensionella php -arrayen. De är själva matriser. De där. en flerdimensionell array är en samling arrays. Deras häckningsnivå kan vara så stor som du vill.

Nu tror jag att det är definitivt klart 🙂

Jag skulle också vilja lyfta fram begreppet associerad array php separat. I verkligheten är de inte lika vanliga som vanliga, men de har fortfarande en plats att vara.

Kort sagt, det här är matriser där nyckeln och värdet för matriselementet är oupplösligt länkade och det finns en viss logisk koppling mellan dem, som under inga omständigheter ska brytas.

Ett exempel på en associativ matris är följande konstruktion:

Array (=> 12 [namn] => Ivanov Ivan Ivanovich [medelpunkt] => 3)

Som du kan se här är värdena för nycklarna och värdena för arrayelementen nära besläktade och i inget fall bör denna relation brytas. På grund av detta kallas associativa matriser ofta "ordböcker" eller "referensböcker".

Därför måste denna funktion beaktas vid sortering av en php -array, eftersom inte alla metoder är lämpliga för sådana strukturer.

I själva php skapas matriser på två sätt:

1. $ books = array ('ABC', 'ABC', 'Dictionary); eller $ books = array ('azb' => 'ABC', 'buk' => 'Primer', 'slov' => 'Dictionary'); Det andra alternativet används när ett element måste anges specifikt med ett nyckelfält (relevant för associerade matriser). Om du inte anger det är tangenterna för arrayelementen som standard nummer. Börjar med 0 (noll).
2. $ böcker = 'Alfabet'; $ böcker = 'Primer'; $ böcker = 'Primer';

I båda fallen kommer $ books att vara en array. Så om du stöter på sådana konstruktioner i koden för din webbplats kommer det inte längre att vara något obegripligt för dig 🙂

Om du vill lära dig mer om php -matriser rekommenderar jag dig följande video:

Låt mig påminna dig om att för att kunna se strukturen för matrisen på din skärm, efter att du har deklarerat matrisen i platskoden, måste du skriva följande konstruktion:

Eko "

"; print_r (array_variable); die ();
Om variabeln du skriver ut är en array börjar texten med följande rad:
Array (...
Och några fler ord om ämnet i vår artikel - sortera matriserphp.
Som du kan föreställa dig är data i matriserna strukturerade och elementen ordnade i en viss sekvens.  För att ändra det behöver vi bara sortera php-arrayen, som implementeras av färdiga språkfunktioner.
Därför är allt vi behöver göra att ringa till den nödvändiga funktionen efter att deklarerat matrisen och ange den som en parameter.
Låt oss gå vidare till en översikt över själva funktionerna.
Php array -sorteringsfunktioner
En fullständig lista över dem presenteras i den officiella php -dokumentationen:
För att sortera php -arrayen med en specifik funktion måste du ringa den efter att ha deklarerat matrisen och fyllt den med värden och specificera vår array som parametrar för den.  Till exempel:
$ bilar = array ("Toyota", "Mazda", "Mitsubishi");  sortera ($ bilar);
Låt oss kort överväga funktionaliteten för var och en av dem.  Funktionerna kommer att specificeras i det format i vilket de kommer att behöva anropas i koden, d.v.s.  "Namn (parameter1, parameter2, ...);".
Glöm inte att lägga ";" efter funktionssamtalet, eftersom  utan det kommer ett trevligt felmeddelande att visas på skärmen 🙂
Som ett illustrativt exempel, låt oss ta en enkel endimensionell matris där både nycklar och värden kommer att vara oordnade så att resultaten av utförande av funktioner blir mer visuella och begripliga.
Array (=> 11 => 18 => 9)
Så hur kan du sortera en array i önskad ordning i php?
Fungerar enkel sortering av php -array efter värde
Om du föredrar att läsa videomaterial, skulle jag vilja rekommendera dig att titta på den här videon, som tydligt och tydligt visar funktionen för funktionerna för att sortera php -arrayen från detta block:
 
Om du fortfarande har frågor efter det kan du hitta mer detaljerad information om varje funktion nedan.
sort ($ array, $ flagga);- en av de enklaste och mest populära funktionerna.  Gör att du kan sortera en matris i stigande ordning i php, med hänsyn till elementens värden, d.v.s.  de kommer att rankas från det lägsta värdet till det högsta.  Den tar en matrisvariabel och en av sorteringsflaggorna som parametrar, vilket gör att du kan ändra sorteringsbeteendet.
Lista över flaggor:
SORT_REGULAR - element jämförs utan att ändra typ
SORT_NUMERIC - objekt jämförs som siffror
SORT_STRING - objekt jämförs som strängar
SORT_LOCALE_STRING - strängjämförelse, men med hänsyn till den aktuella platsen.
SORT_NATURAL - strängjämförelse av element, med tanke på deras naturliga ordning (som natsort)
SORT_FLAG_CASE - sorteringskänslig sortering av php -arrayelement (kan kombineras med SORT_STRING eller SORT_NATURAL bitvis ELLER).
Men i de flesta fall är resultatet av funktionsutförandet korrekt även utan dessa kvalificerande flaggor.  Som standard (om inget anges) kommer SORT_REGULAR att användas.
Vårt testarray, efter att ha kallat funktionen sort (), kommer att se ut så här:
Array (=> 9 => 11 => 18)
Som du kan se, efter att ha sorterat matrisen efter värden, ändrades också deras nycklar sedan  sort fungerar utan att upprätthålla ett nyckel-värde-förhållande, vilket anges i den officiella php-dokumentationen.
Som ett resultat är detta alternativ lämpligt för de allra flesta fall.
rsort ($ array, $ flagga);- en funktion som är en slags antagonist.  Antagonisten, eftersom den sorterar matrisen på samma sätt, bara inte i stigande ordning, utan i fallande ordning, d.v.s.  php -arrayelementen med de största värdena kommer först.
Du kan också skicka två parametrar till den: själva matrisen och sorteringsflaggan, och liksom sortering är den mer lämplig för endimensionella matriser.  Efter att ha kallat den här funktionen kommer vår testmatris att ta följande form:
Array (=> 18 => 11 => 9)
asort ($ array, $ flagga);- php -funktion för att sortera en array efter värde, vars mekanism också är mycket lik sortering.
Med det enda undantaget att det tillåter att sortera php-arrayen efter värdet på dess element samtidigt som nyckel-värde-förhållandet bibehålls.
Således är denna funktion bra för php associerande arraysortering, d.v.s.  strukturer där denna koppling är logisk och viktig.
Elementen kommer att ordnas i stigande ordning, sedan  det låter dig sortera den php -associerande matrisen efter värde samtidigt som nycklarna bevaras.
Du kan också skicka två parametrar.  Vårt testarray kommer att se ut så här:
Array (=> 9 => 11 => 18)
Som du kan se är skillnaden från sortering bara i att behålla nycklarna till de värden som php -arrayen sorteras efter.  Detta kallas att upprätthålla nyckel-värde-förhållandet, vilket är otroligt viktigt när man sorterar php-associativa matriser.
arsort ($ array, $ flagga);Är en annan php -funktion för att sortera en array efter värde.  Antagonist av asort.
Det fungerar på samma princip som den nämnda funktionen, endast php -array -sorteringen i detta fall kommer att vara i fallande ordning.  Också ett bra alternativ när du sorterar php -associativa matriser.
Efter att ha kallat den här funktionen kommer vårt exempel att se ut så här:
Array (=> 18 => 11 => 9)
Funktioner för avancerad sortering php -array efter värde
Detta funktionsblock, till skillnad från de tidigare, som gjorde det möjligt att ändra ordningen i fallande / stigande ordning, gör att du kan lägga till variation och ordna element i olika sekvenser, annorlunda än de "traditionella".
Denna funktion gör dem lämpliga för att lösa olika icke-standardiserade uppgifter, ibland mycket intressanta 🙂
natsort ($ array);- den här funktionen ger variation till familjen sorteringslika lösningar, sedan  mekanismen för dess arbete skiljer sig fundamentalt från dem.  Natsort har bara en inmatningsparameter - detta är en matris som ska sorteras, vars värden kommer att ordnas i en människokänd ordning.  Denna algoritm kallas "naturlig ordning", som på ryska betyder "naturlig ordning".  För att förstå innebörden av detta uttalande, tar vi en annan array som ett exempel:
Array (=> student5 => student1 => student10)
Dessutom upprätthåller natsort-funktionen ett nyckel-värde-förhållande.  Därför kommer vi att jämföra dess arbete med asort, vilket är så likt det som möjligt.  Efter att ha ringt den senare kommer vår array att ta följande form:
Array (=> student1 => student10 => student5)
Om vi ​​kallar natsort kommer den resulterande matrisen att vara så här:
Array (=> student1 => student5 => student10)
Jag tror att du kan se skillnaden nu och hur natsort fungerar för dig :-)
shuffle ($ array);- en underbar och mycket användbar funktion som du kan blanda en php -array med och ordna dess element i slumpmässig ordning.
Det är mycket bekvämt när du behöver ordna produkterna från en onlinebutik i en kategori eller på en annan sida i slumpmässig ordning, eller när du går till en visitkortsajt, visa användare olika informationsblock varje gång i en annan sekvens.
Nyckel-värde-förhållandet bevaras dock inte.  Det vill säga den matris som vi använde i föregående exempel, jag tog personligen formen:
Array (=> student10 => student5 => student1)
Efter varje funktionsanrop kommer elementens ordning att vara annorlunda.
De funktioner som vi har övervägt tidigare är ganska enkla och mekanismen för deras funktion är tydlig.  En array skickas som en parameter, vars innehåll måste sorteras efter värdena på dess element, samt en flagga som kan ändra sorteringsbeteendet (du kan enkelt klara dig utan det).
Det är ganska populärt bland programmerare, eftersom  låter dig lösa alla sorteringsproblem (med olika algoritmer) med dess funktion.
En av dessa uppgifter är php av det obligatoriska fältet.
För att illustrera hur följande funktioner fungerar, låt oss ta följande array som ett exempel:
Array (=> Array (=> 32) => Array (=> 11) => Array (=> 27))
Som du kan se är det flerdimensionellt, eftersom  dess element är matriser, vars struktur är identisk: de har alla ett fält med "id" -tangenten.  Och nu är vår uppgift att sortera dessa element i stigande ordning, d.v.s.  så att elementen i huvudmatrisen ligger i enlighet med värdena för fälten i delraderna.
Jag måste säga, en ganska vanlig uppgift.  Följande funktioner hjälper oss att lösa det:
usort ($ array, 'funktion');- php -funktion för att sortera en flerdimensionell matris efter önskat fält.
Låter dig sortera elementen i en php-array utan att behålla nyckel-värde-förhållandet i enlighet med en anpassad funktion vars namn skickas som den andra parametern när du anropar usort.
Själva funktionen beskrivs separat.  För vårt exempel, för att sortera elementen i en flerdimensionell php -array med ['id'] -fältet i stigande ordning, kommer den anpassade funktionen att se ut så här:
Funktion myCmp ($ a, $ b) (if ($ a ["id"] == $ b ["id"]) return 0; return $ a ["id"]> $ b ["id"]? 1 : -1;)
Allt vi behöver nu för att börja sortera är att ringa usort ($ array, 'myCmp');  på rätt plats i koden.  Anger namnet på en matrisvariabel som den första parametern.
Som ett resultat får vi följande:
Array (=> Array (=> 11) => Array (=> 27) => Array (=> 32))
uasort ($ array, ‘funktion’);- en annan php -funktion för att sortera en flerdimensionell matris efter önskat fält.
Fungerar ungefär som usort, men behåller en nyckel-värde-relation, vilket gör den lämplig för att sortera flerdimensionella associativa matriser.
Den anpassade funktionen för vårt exempel kommer att vara densamma.  Resultaten av dess utförande kommer att se ut så här:
Array (=> Array (=> 11) => Array (=> 27) => Array (=> 32))
För att ändra sorteringsordning för element och göra några ytterligare datatransformationer, kommer det att bli nödvändigt att redigera den användardefinierade funktionen, som du kanske gissat själv 🙂
Till exempel, om dina matriser, som är element i originalet, kommer att innehålla ett fält ['namn'] med ett strängvärde, kommer en anpassad funktion för att sortera en flerdimensionell php -array med detta fält i stigande ordning att se ut så här:
Funktion myCmp ($ a, $ b) (if (strcasecmp ($ a ["namn"], $ b ["person"] ["namn"]) == 0) return 0; return strcasecmp ($ a ["namn "], $ b [" namn "])> 0? 1: -1;)
Att sortera php -matriser med anpassade funktioner är inte det enklaste alternativet, men det är väldigt flexibelt när det gäller anpassning, och om du behärskar det blir det din favoritlösning.
array_multisort ($ array1, $ array2, $ flagga);- till slut sparade jag den mest hemska och oklara php -funktionen för att sortera en array.  Den accepterar två matriser som inmatningsparametrar och samma sorteringsflaggor som kan specificeras i sorteringslika funktioner.  Array_multisort fungerar enligt följande: den första parametern är en matris som ska sorteras, som den andra matrisen är sorteringsordningen för den första specificerad, varefter den andra matrisen sorteras analogt med den första.  I stället för en array som representerar sorteringsordningen kan du använda SORT_DESC -konstanterna för att sortera arrayen i fallande ordning och SORT_ASC i stigande ordning.  Till all denna förvirring kan du också lägga till sorteringsflaggor, som kan komma efter alla matriser.
$ böcker = array (32, 11, 27);  $ sort_array = array (1, 2, 3);  array_multisort ($ böcker, $ sort_array);
I det här exemplet har jag sorterat en enkel endimensionell array $ -böcker enligt arrayen $ sort_array.  Som ett resultat fick den första matrisen följande form:
Array (=> 11 => 27 => 32)
Och den andra blev så här:
Array (=> 2 => 3 => 1)
Det vill säga, det sorterade enligt det första.  Här är en sådan persilja 🙂
Mer information om array_multisort finns i nästa video.  Även där hittar du ytterligare exempel på dess användning:
 
Med den här funktionen kan du också sortera flerdimensionella matriser:
$ books = array (array (32), array (11), array (27));  $ sort_array = array (1, 2, 3);  array_multisort ($ böcker, $ sort_array);
$ Books -matrisen kommer att se ut så här:
Array (=> Array (=> 11) => Array (=> 27) => Array (=> 32))
Samtidigt kan du i den här funktionen ange flera matriser och sortera efter flera fält.  I det här fallet kommer resultaten av att sortera de tidigare matriserna att påverka de efterföljande, vilket i slutändan kommer att leda till att den sista sorteras enligt olika kriterier.
Här är ett slags "snöboll" i php.
När du sorterar en php-array med den här funktionen bevaras nyckel-värde-förhållandet för associerade matriser, men inte för numeriska.
Programmerare som har testat driften av olika funktioner noterar att när man sorterar en flerdimensionell array fungerar php array_multisort bättre än usort.
Men array_multisort kan inte hantera alla uppgifter som usort kan utföra.  Till exempel samma sortera en flerdimensionell matrisphp med det obligatoriska fältet...  Så i varje enskilt fall måste du analysera dina chanser att lyckas när du använder en eller annan design.
För mig själv kan jag säga att jag ogillar array_multisort lite på grund av dess förvirring och ökad hjärnstress, som åtföljs av försök att representera den resulterande matrisen sorterad med dess hjälp.
Därför försöker jag att inte använda det i onödan, föredrar användarvänliga och enklare funktioner, vilket jag uppmanar dig att göra också :)
De tidigare diskuterade funktionerna låter dig sortera matriser i php efter elementens värde.  Låt oss prata om hur du kan utföra en liknande åtgärd på objektnycklar.
Php -funktioner för att sortera en matris efter nyckel
Innan vi kommer till översikten över funktionerna i denna grupp skulle jag vilja säga att de alla har en sak gemensamt - de bevarar alla ett nyckel -värde -förhållande.  Annars kunde det faktiskt inte vara det, eftersom  då hade det ingen mening från dem 🙂
Sådan är funktionen.  Låt oss titta närmare på varje funktion.
ksort ($ array, $ flagga);- funktionen är analog med asort, bara ordningen av elementen i matrisen sker inte av värden, utan av tangenter.
Denna konstruktion har två inmatningsparametrar: php -matrisen som ska sorteras och en av sorteringsflaggorna, en komplett lista över vilken du kan hitta i beskrivningen av sorteringsfunktionen (dess användning är valfri).  Denna php -funktion låter dig sortera en array i stigande ordning.
För att visa hur det fungerar, låt oss återgå till exemplet som beskrivs i början av artikeln:
Array (=> 11 => 18 => 9)
Om du sorterar det med ksort kommer resultatet att se ut så här:
Array (=> 18 => 9 => 11)
Jag tror att allt är enkelt och tydligt.
krsort ($ array, $ flagga);- en annan php -funktion för att sortera en array efter nyckel, mycket lik den föregående.
Den enda skillnaden är att den sorterar php -arrayen i fallande ordning.  Det vill säga, det är en antagonist av ksort, precis som rsort är för sort.
Den har också två ingångsparametrar: matrisen som ska sorteras och en av nycklarna.  Efter att ha startat det kommer vårt exempel att se ut så här:
Array (=> 11 => 9 => 18)
Jag tycker att kommentarer är överflödiga 🙂
ukrsort ($ array, ‘funktion’);- en analog av den tidigare nämnda php -funktionen för att sortera en matris efter nyckel - usort.
Det fungerar på samma princip: det sparar "key-value" -relationen och php-arrayen sorteras i enlighet med den användardefinierade funktionen, vars namn skickas som den andra parametern.  Den första parametern, oföränderlig, är matrisen som ska sorteras.
Skillnaden mot usort är att den sorterar efter objektnycklar.
För att göra funktionen tydligare använder vi följande exempel:
Array (=> 40 => 0 => 10)
Till exempel måste vi sortera php -arrayen efter nyckel i stigande ordning.  I det här fallet kommer den anpassade funktionen att se ut så här:
Funktion myCmp ($ a, $ b) (om ($ a == $ b) return 0; return $ a< $b ? 1: -1;
}
 
Som ett resultat kommer vår array att se ut så här:
Array (=> 0 => 10 => 40)
Ett otvetydigt plus med att använda den här funktionen är att den kan användas för att sortera php -arrayen efter något ovanligt attribut eller en algoritm.
Låt mig påminna dig om att du bara behöver använda den när tangenterna till arrayelementen har någon betydelse.  Annars är det bättre att använda usort eller andra enklare funktioner.
Här är vår artikel och tog slut (som om du läser så här långt) 🙂
I den försökte jag beskriva så enkelt och samtidigt tydligt och fullt ut alla möjliga sätt att sortera olika typer av matriser i php, säkerhetskopiera mina ord med exempel.
Jag erkänner att publikationen kom ut ganska omfattande och svår att läsa en gång.  Men varje gång du behöver php array sort, kan du alltid hänvisa till den här artikeln för en beskrivning av den funktion du behöver och se exempel på dess användning.
Jag hoppas att informationen var användbar för dig :)
Prenumerera på projektuppdateringar och
När man arbetar på många webbplatser möts ofta frågan om att sortera arraydata i alfabetisk ordning.  Många skriver ytterligare matriser för detta, jämför stora tabeller och iterera över varje namn ... Det här alternativet är inte det bästa, även om vi också kommer att överväga det.  I den här artikeln vill jag erbjuda den enklaste och kortaste vägen, som efter noggrann läsning av manualerna finns i dokumentationen.
PHP alfabetisk matris
Metoden är ganska enkel och består av två steg: inställning av lokal (setlocal) och sortering av matrisen direkt.  Låt oss titta på ett exempel med kommentarer. 
PHP -kod
 setlocale (LC_ALL, "Russian_Russia.1251");  // ställ in språket för ryska bokstäver
// exempel på en matris där ord INTE är i ordning 
$ exempel = array ("bank", "Boris", "vy", "profil", "jägare", "Fedor", "fru", "röst");
Natcasesort ($ exempel, SORT_LOCALE_STRING);  // sortera arrayen okänsligt 
// För CASRELATIONER, använd sort istället för natcasesort
// skriv ut resultatet 
foreach ($ exempel som $ key => $ value) ( 
echo "$ value" (! LANG:; // visa bara ord, inget index 

} 

?>

Demonstration Ladda ner källor 
I demoen kan du se hur manuset fungerar.  Om du vill kan du också ladda ner arkivet med filen.
Om din server inte finns på Windows måste du installera andra platser eller flera samtidigt:
(LC_ALL,"ru_RU.CP1251", "rus_RUS.CP1251", "Russian_Russia.1251");!} 
// Skriver ut ru_RU.CP1251 för FreeBSD 
// Utdata rus_RUS.CP1251 för Linux 
// Output Russian_Russia.1251 för Windows 

Jag kommer att svara på en av frågorna i förväg - platsen för Ukraina i PHP ser ut så här:

Hur ställer jag in lokaliseringen för andra kodningar i PHP?
 // Installera språk för Windows
// Kodning av Windows-1251 
setlocale (LC_ALL, "Russian_Russia.1251");
// Kodning KOI8-R 
setlocale (LC_ALL, "Russian_Russia.20866");
// UTF-8-kodning (använd med försiktighet) 
setlocale (LC_ALL, "Russian_Russia.65001"); 

?>
 
Andra sättet att ordna array alfabetiskt PHP
Om den här metoden inte passar dig och du vill gå den svåra vägen, skapa sedan en rad med följande formulär: 
PHP -kod
=> a 
=> b 
=> i 
=> r 
=> d 
=> e 
=> ё 
=> f 
=> s 
=> och 
=> th 
=> till 
=> l 
=> m 
=> n 
=> o 
=> n 
=> s 
=> med 
=> t 
=> y 
=> f 
=> x 
=> c 
=> h 
=> w 
=> u 
=> b 
=> s 
=> b 
=> öh 
=> u 
=> jag 
Och iterera över den andra matrisen med den första bokstaven. 
Den första bokstaven i ett element i matrisen beräknas enligt följande:
PHP -kod
$ city = "Moskva";  // till exempel element med index 1
$ first_letter = mb_substr ($ city, 0,1, "UTF-8");  // få bokstaven "M" 
Eftersom vi arbetar med ryska bokstäver (multibytkodning) är det bättre att använda funktionen mb_substr, och i slutet är det bättre att specificera datakodningen för variabeln eller arrayen, i vårt fall UTF-8.
Tack för uppmärksamheten!  Jag hoppas att informationen var till hjälp.  Om du har några frågor, skriv i kommentarerna.