Anmerkungen zur PHP-Array-Studie-PHP-Tutorial-php.cn

. Der Code lautet wie folgt:

header('Content-Type: text/html; charset=utf-8');
echo '

'; <br>function var_array($array) <br>{ <br>echo '<pre class="brush:php;toolbar:false">'; <br>var_dump($array); <br>echo '

'; >echo '

'; <br>print_r($array); <br>echo '

'
function getArr($sNum, $eNum=1, $step =1)
{
$arr = range($sNum, $eNum, $step);
$reArr = array();
foreach($arr as $v)
{
$reArr[$v] = rand(0,10);
unset($arr);
return $reArr; */
//--------------- ----- --
//array_change_key_case() ändert die Groß- und Kleinbuchstaben des Array-Index, bestimmt durch den letzten Parameter: CASE_UPPER (in Großbuchstaben umgewandelt), CASE_LOWER (Standard in Kleinbuchstaben umgewandelt)
$ expArr = array(
'fiRsT' => '1',
'sEcoNd' => '2',
'ThIrd' => array(
'HuiMa' => '3',
' nengZhuaNma' => '5',
)
);
printr(array_change_key_case($expArr));//Alles in Kleinbuchstaben umwandeln
printr(array_change_key_case($expArr[' ThIrd'] , CASE_UPPER));//Alles in Großbuchstaben umwandeln und nur einen Indexschlüssel im $expArr-Array konvertieren
//Zusammenfassung: Diese Funktion wirkt sich nur auf eine Ebene des Arrays aus. Und hat keinen Einfluss auf das ursprüngliche Array
echo '

'//------------ - ---------------------------------
//array_chunk($array, $size, false)
//Teilen Sie ein Array in ein mehrdimensionales Array auf. Die Größe bestimmt, wie das Array jedes Mal zu einem mehrdimensionalen Array wird. True/False bestimmt, ob die Schlüsselwerte des neuen Arrays die Schlüssel des ursprünglichen Arrays erben 🎜>$expArr = array('4 ','2','6','d','2');
printr(array_chunk($expArr, 3));
//Zusammenfassung: Dies Die Funktion wirkt sich nur auf eine Ebene des Arrays aus. Und hat keinen Einfluss auf das ursprüngliche Array
echo '

'//------------ - ---------------------------------
//array_combine($keyArr, $valArr)
/ /Kombiniere zwei Arrays zu einem Array, $keyArr als Schlüssel, $valArr als Wert
$expKey = array('g', 'd', 't'); ', '8', '7');
printr(array_combine($expKey, $expVal));
//Diese Funktion wirkt sich auch nur auf eine Ebene des Arrays aus und gibt ein neues Array zurück
echo '

'
//-------- --------------------
//array_count_values($array)
//Zähle die Anzahl der Vorkommen jedes Werts im $array-Array. Und Verwenden Sie diesen Wert als Schlüssel des neuen Arrays und die Anzahl der Vorkommen als Wert
$array = array('v1'=>'265', 'v2'=>'352', 'v3'= > ;'265', 'v4'=>'349', 'v5'=>'265');
printr(array_count_values($array));
//Zusammenfassung: Diese Funktion kann nur werden für statistische Werte vom Typ String und Integer verwendet, andere Typen geben eine Warnung aus!
echo '

'; ------ ---------
//array_diff($array1, $array2...)
/ /Wenn $array1 als Basisarray verwendet wird, erscheint sein Wert in keinem anderen Parameterarray, um ein neues Array zu bilden
$arr1 = array('v4'=>458, 'gren', 'b5', 'a5' );
$arr2 = array('v4'=>598, 'red', 'a5', 'c4'); /Zusammenfassung: Nehmen Sie ein Array und fügen Sie es in eine Reihe von Arrays ein, um die Werte zu finden, die nicht im Array enthalten sind.
//array_intersect($array, $parArr, ...) .)
//Diese Funktion hat die gleiche Funktion wie array_diff, außer dass array_intersect() allgemeine Daten zurückgibt, während array_diff die Daten sind, die nur in $array vorhanden sind
//
echo '

'
//------------- ----- ---------
//array_diff_assoc($array1, $array2...)
// Identisch mit der Funktion array_diff(), aber diese verwendet auch den Schlüssel zum Vergleich
//
echo '

'; /--------------------- -----------
//array_diff_key
//Gleich wie die Funktion array_diff()
//Aber diese benötigt nur $ Der Schlüssel von array1 wird mit anderen Parameterarrays
//
durchsuchtecho '

'; -----------------------
//array_diff_uassoc($arr1, $parArr...., Callback-Funktion)
//Gleiche Funktion wie array_diff (), aber der Benutzer muss eine Rückruffunktion definieren
//Die Funktion dieser Funktion wird nicht verstanden
//
echo '

< ;br/>' ; ------------ -
//array_diff_ukey($arr1, $parArr...., Callback-Funktion)
//Die Funktion ist die gleiche wie array_diff_key(), aber ähnlich array_diff_uassoc, es erfordert eine Rückruffunktion
//
//
echo '

'; --------------- --------------
//array_fill ($startInt, $numInt, $value)
//Der $-Wert wird in ein neues Array eingefügt. Die Startindexposition des neuen Arrays wird durch $startInt bestimmt, wie viele Indizes von diesem Array generiert werden .
//Tipp: Zusätzlich zu $value müssen $startInt und $numInt Zahlen sein, sonst wird ein Fehler gemeldet
printr(array_fill(2, 5, 'value')); Zusammenfassung: Noch nicht darüber nachgedacht. Wofür ist es?
echo '

'; ------------- -----------
//array_fill_keys($arrKeys, $ value);
//Die Funktion ist dieselbe wie die Funktion array_fill( ). Aber hier wird $arrKeys [der Wert eines Arrays] als Schlüssel des neuen Arrays verwendet
$arrKeys = array('45', 'd', 'b', 'c'); array_fill_keys ($arrKeys, 'value'));
echo '

'; ----------------------------------
//array_filter($arr, callBack Rückruffunktion)
//Filterfunktion: Beurteilen Sie den Wert des $arr-Arrays. Wenn die CallBack-Rückruffunktion „true“ zurückgibt, fügen Sie den aktuellen Schlüssel und Wert zum neuen Array hinzu.
//TIPP: Die Callback-Funktion kann eine Regel schreiben Filtern Sie die Array-Schlüssel heraus, die nicht den Regeln entsprechen
function cb($val)
{
return $val%2 == 0;
$array = array(' k1' =>3, 'k2'=>5,'k4'=>54654, 'k5'=>8794, 8945, 32549564);
printr($array, 'cb'); 🎜> //Tipp: Es wird empfohlen, den Namen der Rückruffunktion in Anführungszeichen zu setzen
//Zusammenfassung: Diese Methode kann in eine Integration der Datenfilterung
unset($array); '
< ;hr/>
'; -------- -------------
//array_flip($array)
//Konvertieren Sie die Beziehung zwischen Schlüssel und Wert im Array. Es werden nur Schlüssel vom Typ string und integr unterstützt. Für andere Typen wird eine Warnung ausgegeben und der betreffende Schlüsselwert wird nicht konvertiert. Wenn im generierten neuen Array die Schlüssel gleich sind, werden die Werte der vorhandenen Schlüssel kontinuierlich ersetzt
$arr = array('k1'=>'v1', 'k2'=>' v2', 'k3'=>'v4', 'k4'=>'v4', 'k5'=>'v5');
unset ($ arr);
echo '

'/-------------- -- ----------------------------
//array_key_exists($key, $array)
//Bestimmen Sie, ob Ein Schlüssel existiert im aktuellen Array und gibt bool zurück. Es kann auch verwendet werden, um Objekte zu beurteilen
$array = array('cb' => 234, 'dv'=>45, 'one'=>897);
if(array_key_exists('one ', $ array))
echo 'Existiert in diesem Array';
else
echo 'Existiert nicht'
echo '

< br/> '; --------- --
//array_keys($array, $selSearch_value)
//Gibt die Schlüsselnamen im Array zurück und bildet ein neues Array. Wenn der Wert $selSearch_value angegeben ist, dann Der Schlüsselname im Array, der $selSearch_value entspricht, wird zurückgegeben
$array = getArr(4, 10);
printr(array_keys($array, '5 '));//Suche mit Wert
unset($array);
//Zusammenfassung: Dies kann auch für Datenstatistiken und Datenvergleichsüberprüfung verwendet werden
echo '
< hr/>
'; ------------
echo 'array_map:'
//array_map('callBack', $array,...)
//Gib die übergebene Funktion zurück und Rückgabewert der Callback-Funktion zurückgeben
//Callback-Funktionen können auch ein Array zurückgeben. Darüber hinaus akzeptiert die Callback-Funktion nur den Wert in einem Array, der in
function mapCb($n)
{
return $n*$n*$n; array = getArr (4, 15);
printr(array_map('mapCb', $array));
//----------------
//array_merge($array,$array2...)
//Kombinieren Sie mehrere Arrays zu einem Array und schreiben Sie den numerischen Index neu.
$arr1 = getArr(1, 5);
$arr2 = getArr(5, 10);
printr(array_merge($arr1, $arr2));
//Zusammenfassung: Weitere Arrays um ein neues Array zu bilden.
echo '

'; ------ ---------
//array_merge_recursive($arr1, $arr2....)
//Die Funktion ist die gleiche wie oben. Aber die Funktion wird ein neues Array mit Werten mit demselben Schlüsselnamen bilden, anstatt sie zu ersetzen
//Aber wenn Sie es verwenden möchten, verwenden Sie es entsprechend der tatsächlichen Situation
echo '

< ;br/>'
//-------------- ------------ -------
//array_multisort()
//Mehrdimensionale Array-Sortierung, derzeit ist nur zweidimensionale Array-Sortierung implementiert. Dreidimensionale Schätzung kann nicht angeordnet werden
//Diese Funktion ändert direkt die Reihenfolge des Mitgliedsarrays
echo '

'; >//--- ------------------------------------------
//array_pad($ arr, $size, $value)
//Füllen Sie das Array, wenn die aktuelle Länge von $arr kleiner als $size ist, dann verwenden Sie $value, um das $arr-Array bis zur Länge von zu füllen $arr ist gleich $size
//Wenn die Länge von $arr größer oder gleich $size ist, füllt diese Funktion $arr nicht. Wenn $size kleiner als 0 ist, wird es auf der linken Seite von $arr ausgefüllt, wenn es größer als 0 ist, wird es auf der rechten Seite ausgefüllt
echo '

';
//---- ---------------- -----------
//array_pop($array )
//Entferne den letzten Schlüssel des Arrays.
echo '

'; ------ ---------------
//array_product($arr)
// Gibt das Produkt aller Werte in einem Array zurück.
//Tipp: Diese Funktion kann keine nicht numerischen Daten verarbeiten. Wenn das eingehende Array „a, b und andere Zeichenfolgen“ enthält, meldet PHP einen Fehler
$arr = array(4,5,5);

'
//--------- - -------------------
//array_push($arr, $keyArr)
//Füge $keyArr am Ende des $arr-Arrays zum Hinzufügen hinzu in Form von Schlüssel/Stapel.
//Der Unterschied zwischen den beiden Funktionen array_merge() und array_merge_recursive():
// arrap_push() fügt ein $keyArr zu $arr hinzu, während die anderen beiden Funktionen mehrere Funktionen zu einer Funktion
echo verbinden '

'
//------------------ ------ ---------
//array_rand($arr, $num=1)
//Erhalten Sie das aktuelle Array. Die Anzahl von Die herausgenommenen Schlüssel werden durch $num bestimmt, der Standardwert ist 1
//Wenn $num 1 ist, wird eine Zeichenfolge zurückgegeben
//Wenn $num>1 && $num//Andernfalls meldet PHP einen Fehler
$arr = getArr(5, 15); /> ;

'
//------------- ---- ---------------
//array_reduce()
//Ähnlich wie array_map() werden die Werte im Array durch den Rückruf verarbeitet Funktion und der Rückgabewert wird akzeptiert
//Diese Funktion gibt einen String zurück. Es berechnet alle Werte im Array und gibt den berechneten Wert zurück, während array_map den Wert unter jedem Schlüssel berechnet und das Array zurückgibt
//Nicht zu klar, Beispiele finden Sie im Handbuch
echo '

'
//---------- ---------------------
//array_replace($array, $parArr,...)
//Verwenden Sie den Schlüssel im Parameterarray Der Wert ersetzt den Wert desselben Schlüssels in $array
//Wenn der entsprechende Schlüssel nicht im nachfolgenden Parameterarray im $array-Array gefunden wird, fügen Sie ihn am Ende des neuen Arrays hinzu
/* $arr = getArr(4, 10);
$arr2 = getArr(6, 15);
printr($arr2);*/
$base = array ('citrus' => array( "orange") , 'berries' => array("blackberry", "raspberry"),
$replacements = array('citrus' => array(' Ananas'), 'berries' => array('blueberry'));
printr(array_replace($base, $replacements));
' ; ------------- -
//array_replace_recursive() Rekursive Ersetzung
//Die Funktion ist dieselbe wie array_replace(). Der Unterschied besteht darin, dass array_replace_recursive() mehrdimensionale Arrays bearbeiten kann, ohne die Struktur von $array zu ändern, während array_replace() schließlich ein eindimensionales Array
zurückgibt$base = array('citrus' => array( "orange") , 'berries' => array("blackberry", "raspberry"),
$replacements = array('citrus' => ; array('pineapple'), 'berries' => array('blueberry'));
printr(array_replace_recursive($base, $replacements)); hr/>
';
//--------------------------------- ------------
//array_reverse($arr)
//Ordnen Sie die Schlüssel im Array in umgekehrter Reihenfolge an
echo '

';
//---------------------------------- -----------
//array_search($value, $array)
//Suchen Sie im $array-Array nach dem Schlüsselnamen mit dem Wert $value
//Nicht gefunden Geben Sie dann false zurück
//Wenn sich hinter dem Array $array mehrere $values befinden, wird nur der erste übereinstimmende Schlüssel zurückgegeben
//Diese Funktion ähnelt array_keys(), der Unterschied liegt in der Rückgabewert: array_search() Es wird nur ein passender Schlüsselname zurückgegeben, während array_keys() ein eindimensionales Array bestehend aus allen passenden Schlüsseln zurückgeben kann
echo '

< br/> '; --------- --
//array_shift($arr)
//Entfernen Sie den ersten Schlüssel im aktuellen $arr-Array und ordnen Sie die folgenden numerischen Indizes neu an (aber ändern Sie nicht das Original). Reihenfolge), nicht-numerische Indizes konstant.
//Diese Funktion ähnelt array_pop(), der Unterschied besteht darin, dass array_pop() die letzte entfernt, array_shift() den Kopf entfernt
echo '

< ;br/> ;';
//----------------------- ---------- ---
//array_slice($arr, $offset, $length=0, false) Array-Interception
//Gibt den Offset ab $offset im aktuellen zurück $arr-Array, insgesamt $length-Elemente/ Schlüssel und ein neues Array bilden, um zurückzugeben
//Wenn $offset oder $length eine negative Zahl ist, dann wird sie in die entgegengesetzte Richtung versetzt
//Es fühlt sich an ähnlich wie substring() string interception
//Direkt Verwenden Sie das Beispiel im PHP-Handbuch
$input = array("a", "b", "c", "d", "e"
$output = array_slice($input, 2); // gibt „c“, „d“ und „e“ zurück
$output = array_slice($input, -2, 1); // gibt „d“ zurück "
$output = array_slice($input, 0 , 3); // gibt „a“, „b“ und „c“ zurück
// beachten Sie die Unterschiede in den Array-Schlüsseln
printr(array_slice ($input, 2, -1));
printr(array_slice($input, 2, -1, true));
echo '

';
//--- ------------------------------------- -----
//array_spslice($ arr, $offset, $length)
//Genau das Gegenteil der Funktion array_slice(), diese Funktion entfernt die Elemente zwischen $offset und $length
unset($arr);
echo '< ;br/>

'//------------- ------------ -------------------
//array_sum($arr)
//Summiere und akkumuliere alles Die Werte im $arr-Array, wenn es sich um einen nicht numerischen Wert handelt, versuchen, die Typen zu konvertieren, aber die meisten davon sind nach der Konvertierung 0
//Diese Funktion wirkt sich nur auf eine Ebene von Arrays aus, ähnlich wie array_product()
$arr = array(
45,56, ' a', 'b'=>getArr(1, 2),
printr($arr); 🎜>echo 'array_sum($arr)',array_sum($arr);
echo '

'; -------------------------
//array_values($arr )
//Extrahieren Sie die Werte im $arr-Array, um ein neues Array von
$arr = array(
'k1'=>45,'k2'=>56 , 'k3'=>'a', 'b'=>getArr(1, 2 ),
printr(array_values($arr)); >

'
//- ------------- -------------------
//array_unique ($arr) Ordnen Sie das Array neu an.
//Ordnen Sie das Array $arr neu an und filtern Sie die doppelten Werte. Mehrere identische Werte behalten nur den ersten
echo '

'
//--------- -----------------------------------
//array_walk($arr, callback[callback function ], $sel_perfix='')
//Sende jeden Schlüssel unter dem aktuellen Array zur Verarbeitung an die Rückruffunktion
//Wenn der Parameter $sel_perfix hinzugefügt wird, benötigt die Rückruffunktion auch drei Parameter zum Empfangen, andernfalls ein Fehler wird gemeldet
//Diese Funktion betrifft nur eine Ebene
$fruits = array("d" => "lemon", "a" => "orange", "b" => „Banane“, „c“ => „Apfel“);function test_alter(&$item1, $key, $prefix)
{
$item1 = "$prefix: $item1"}
printr(array_walk($fruits, 'test_print')) ;
array_walk($fruits, 'test_alter', 'fruit');
echo '

'; ---------------------------------------------
// array_walk_recursive( )
//Die Funktion ähnelt array_alk(); aber sie rekursiert jede Ebene des Arrays in $arr und das zurückgegebene Array ändert nicht die Struktur des ursprünglichen Arrays
echo '
< hr/>
' ----- ------------
//arsort($arr)
//Sortieren Sie das Array nach dem Namen des Array-Schlüssels, und Sie können die Buchstaben sortieren. Wenn die Sortierung fehlschlägt, wird null zurückgegeben
echo '

'
//----------- -- --------------------------------
//asort()
//Die Funktion ist Ähnlich wie bei arsort( ), der Unterschied ist: asort() sortiert die Werte

Das Obige ist der Inhalt der PHP-Array-Studiennotizen. Weitere verwandte Artikel finden Sie auf der chinesischen PHP-Website ( www.php.cn)!