# Array Element anhand des Index als Schlüssel entfernen.



## Mik3e (5. November 2006)

Hi zusammen,

Folgendes Problem: Ich muss aus einem Stack ein bestimmtes Element anhand seines Keys entfernen. Natürlich gebe es die möglichkeit den Array mit foreach zu durchlaufen, das betroffene Element zu überspringen und einen neuen Stack zu bilden. Ist aber ein recht mühsam und vor allem langsam.

Daher meine Frage: Gibt es eine Array-Funktion, mit der man ein Element gezielt droppen kann?

Beispiel:

```
array_push($testArray,"a");
array_push($testArray,"b");
array_push($testArray,"b");
array_push($testArray,"d");

/* Array sieht nun folgendermassen aus:
$testArray[0] -> a
$testArray[1] -> b
$testArray[2] -> c
$testArray[3] -> d
*/

// Jetzt das zweite Element "b" mit dem Index 1 löschen. Habe die gesuchte Funktion mal array_drop_by_key() genannt :)
array_drop_by_key($testarray,1);

/* Array nach der Operation:
$testArray[0] -> a
$testArray[1] -> c
$testArray[2] -> d
*/
```
Vielleicht kennt ja jemand eine Funktion, die genau das kann!?

Ciao,
Mike


----------



## sk4r (5. November 2006)

Warum speicherst du deine Arrays nicht in eine DB und machst dann erst deinen Drop?
Mit Geschwindigkeit hat das eigentlich nichts zutun (soweit ich weiß).


----------



## Azi (5. November 2006)

Hallo,

meinst du sowas wie unset()?

Azi


----------



## Marvin Schmidt (5. November 2006)

Hallo Mike,

es ließe sich einmal - wie bereits von Azi erwähnt - [phpf]unset[/phpf] verwenden.
Ich weiß nicht was dein genaues Vorhaben ist, aber wenn du alle doppelten Array-Elemente entfernen willst, dann steht dir dafür die Funktion [phpf]array_unique[/phpf] zur Verfügung.

Gruß
Marvin


----------



## Matthias Reitinger (5. November 2006)

Hallo,


```
<?php

function array_remove(&$array, $key) {
	if (!isset($array[$key])) return NULL;
	$value = $array[$key];
	unset($array[$key]);
	$array = array_values($array);
	return $value;
}

$testArray = array('a', 'b', 'c', 'd');

print_r($testArray);
# =>
# Array
# (
#    [0] => a
#    [1] => b
#    [2] => c
#    [3] => d
# )

echo array_remove($testArray, 1); # => b

print_r($testArray);
# =>
# Array
# (
#     [0] => a
#     [1] => c
#     [2] => d
# )

?>
```
Beachte aber, dass der Stapel umfällt, wenn du aus der Mitte was rausnimmst  Wenn du die diese Operation erlaubst, ist deine Datenstruktur kein Stapel mehr, da du damit das LIFO-Prinzip verletzt.

Grüße,
 Matthias


----------



## sk4r (5. November 2006)

Matthias Reitinger hat gesagt.:


> Hallo,
> 
> 
> ```
> ...




Hmm Matthias,
habe eben genau das selbe posten wollen. Wer zuerst kommt, malt zuerst .
Aber so funktioniert es.


----------



## Mik3e (5. November 2006)

Hi,

Ja, das man es so machen kann ist mir klar 
Ich dachte es gibt bereits eine Funktion, mit der ich genau das erreichen kann. Ich würde die Funktion aber etwas anders bauen:

1) Ein Element nach dem anderen vom Stack poppen
2) Wenn das aktuelle Element == dem Element, dass entfernt werden soll, dann fallenlassen
3) Wenn das aktuelle Element <> dem Element, dass entfern werden soll, push auf einen neuen Stack

Damit haben ich auch kein Problem mit LIFO und einem Loch im Stapel 
Schade, dann muss ich mir die Funktion wohl schreiben.

zu unset(): Damit kann ich höchsten den gesamten array einstanzen, und das wäre nicht ganz Sinn der Sache 

Danke an Euch alle, ich poste dann die fertige Funktion (falls sie später mal wer brauchen sollte).

Ciao,
Mike


----------



## Mik3e (5. November 2006)

So, für alle die es interessiert, hier eine kleine Funktion die das erledigt ($_SESSION['basket'] ist der originäre Array):


```
function dropItem($index)
	{
		$newStack=array();
		foreach($_SESSION['basket'] as $key => $value) {
			if ($key<>$index) {
				array_push($newStack,$value);
			}
		}
		
		$_SESSION['basket']=$newStack;
	}
```

Ciao,
Mike


----------



## Matthias Reitinger (5. November 2006)

Hallo,

und inwiefern unterscheidet sich das jetzt von außen gesehen von meiner Implementation (abgesehen davon, dass bei dir das zu bearbeitende Array explizit in der Funktion angegeben ist)?



Mik3e hat gesagt.:


> zu unset(): Damit kann ich höchsten den gesamten array einstanzen, und das wäre nicht ganz Sinn der Sache


Hast du dir meinen Beitrag überhaupt durchgelesen?

Grüße,
 Matthias


----------



## Online-Skater (5. November 2006)

Matthias Reitinger hat gesagt.:


> Hallo,
> 
> 
> ```
> ...



Wieso ordnet er das Array nachdem du eines aus der Mitte gelöscht hast ?
Wozu in der Funktion $array = array_values($array);

Also gibt es quasi keine fertige Funktion die ein Element löscht und es danach neu ordnet ?


----------



## Matthias Reitinger (5. November 2006)

Hallo,



Online-Skater hat gesagt.:


> Wieso ordnet er das Array nachdem du eines aus der Mitte gelöscht hast ?
> Wozu in der Funktion $array = array_values($array);


Damit hast du dir beide Fragen mit der jeweiligen anderen Frage selbst beantwortet  Das Array wird neu „durchnummeriert“, weil ich [phpf]array_values[/phpf] aufrufe. [phpf]array_values[/phpf] rufe ich auf, damit das Array neu „durchnummeriert“ wird. Alles klar? 



> Also gibt es quasi keine fertige Funktion die ein Element löscht und es danach neu ordnet ?


Nicht dass ich wüsste.
<edit>
Ich revidiere: doch, es gibt eine einfachere Möglichkeit:

```
function array_remove(&$array, $key) {
	return array_splice($array, $key, 1);
}
```
Man muss nur wissen, dass [phpf]array_splice[/phpf] den Nebeneffekt hat, dass die Schlüssel nicht erhalten werden.
</edit>

Grüße,
 Matthias


----------



## Online-Skater (6. November 2006)

Danke Frau Rieger  
"Man muss nur wissen, dass array_splice() den Nebeneffekt hat, dass die Schlüssel nicht erhalten werden."
d.h. er ordnet nicht? d.h. key ist nicht mehr fortlaufend nummeriert.
mfg


----------

