PHP llegar anterior elemento de la matriz saber matriz actual clave

Question

tengo una matriz con teclas específicas:

array(
    420 => array(...), 
    430 => array(...), 
    555 => array(...) 
) 

En mi solicitud sé clave actual (por ejemplo 555). Y quiero obtener el elemento de matriz anterior. En este ejemplo, es un elemento de matriz con la clave 430. ¿Cómo puedo hacer esto en PHP? Intenté trabajar con prev(), pero para esta función deberíamos saber el elemento de matriz actual. No encontré la función, qué establece el elemento actual de la matriz.

Answer 1

Una opción:

para set the internal pointer to a certain position, usted tiene que remitirlo (usando key y next, m aybe hacer un reset antes para asegurarse de que se inicia desde el comienzo de la matriz):

while(key($array) !== $key) next($array); 

Entonces puede utilizar prev():

$prev_val = prev($array); 
// and to get the key 
$prev_key = key($array); 

Dependiendo de lo que se va a hacer con el array después, es posible que desee reset el puntero interno.

Si la clave no existe en la matriz, que tienen un bucle infinito, pero esto podría resolverse con:

while(key($array) !== null && key($array) !== $key) 

por supuesto prev no le daría el valor correcto más, pero supongo que la clave que está buscando estará en la matriz de todos modos.

Answer 2

Puede iterar a través de la matriz en reversa y devolver la siguiente iteración después de encontrar el valor de búsqueda.

$found = false; 
foreach(array_reverse($array, true) as $key=>$value) { 
    if ($found) { 
    print "$key => $value\n"; 
    break; 
    } else if ($key == 555) { 
    $found = true; 
    } 
} 

http://ideone.com/2WqmC

Answer 3

Sólo iterar sobre la matriz

$_index = null; 
foreach($myarray as $index => $value) 
{ 
    if($key == $my_index) // if($key == 550) 
    { 
     break; 
    } 
    $_index = $index; 
} 

echo $_index; //the prev key from 550; 

Una solución alternativa consiste en obtener las claves de la matriz dentro de una matriz enumerada como tal:

$keys = array_keys($my_array); 

como la matriz de teclas es índice, puede mover la tecla anterior como así:

$required_key = (array_search(550,$keys,true) - 1); 

este multará el valor de 550, y devolver su índice dentro de las claves, quitar uno para obtener el índice anterior

clave que tenemos la llave anterior para obtener el valor de la matriz original

$value = $my_array[$required_key]; 

Answer 4

solución con búsquedas rápidas: (si usted tiene que hacer esto más de una vez)

$keys = array_flip(array_keys($array)); 
$values = array_values($array); 
return $values[$keys[555]-1]; 

array_flip(array_keys($array)); devolverá un mapeo de teclas matriz a su posición en la matriz original, por ejemplo,array(420 => 0, 430 => 1, 555 => 2).

Y array_values() devuelve un posiciones de mapeo matriz a valores, por ejemplo array(0 => /* value of $array[420] */, ...).

Así $values[$keys[555]-1] devuelve efectivamente los elementos anteriores, teniendo en cuenta que el actual tiene llave 555.

solución alternativa:

$keys = array_keys($array); 
return $array[$keys[array_search(555, $keys)-1]]; 

Answer 5

Ésta es una solución sencilla para la toma de artículos anteriores y siguientes, incluso si están en los extremos de la matriz.

<?php 

$current_key; // the key of the item we want to search from 

if (isset($array[$current_key+1])) 
{ 
    // get the next item if there is 
    $array_next = $array[$current_key+1]; 
} 
else 
{  
    // if not take the first (this means this is the end of the array) 
    $array_next = $array[0]; 
}  

if (isset($array[$current_key-1])) 
{ 
    // get the previous item if there is 
    $array_prev = $array[$current_key-1]; 
} 
else 
{ 
    // if not take the last item (this means this is the beginning of the array) 
    $array_prev = $array[count($array)-1];   
} 

Answer 6

He resuelto este problema de esta manera:

function getPrevKey($key, $hash = array()) 
{ 
    $keys = array_keys($hash); 
    $found_index = array_search($key, $keys); 
    if ($found_index === false || $found_index === 0) 
     return false; 
    return $keys[$found_index-1]; 
} 

@return clave anterior o falso si ninguna tecla anterior está disponible

Ejemplo:

$myhash = array(
    'foo' => 'foovalue', 
    'goo' => 'goovalue', 
    'moo' => 'moovalue', 
    'zoo' => 'zoovalue' 
); 

echo "TEST: ". getPrevKey('zoo', $myhash); // prints moo 

Answer 7

@Luca Borrione de la solución fue útil. Si usted quiere encontrar ambas teclas anterior y siguiente, puede utilizar la siguiente función:

function getAdjascentKey($key, $hash = array(), $increment) { 
    $keys = array_keys($hash);  
    $found_index = array_search($key, $keys); 
    if ($found_index === false) { 
     return false; 
    } 
    $newindex = $found_index+$increment; 
    // returns false if no result found 
    return ($newindex > 0 && $newindex < sizeof($hash)) ? $keys[$newindex] : false; 
} 

de uso:

// previous key 
getAdjascentKey($key, $hash, -1); 

// next key 
getAdjascentKey($key, $hash, +1); 

Ejemplos:

$myhash = array(
    'foo' => 'foovalue', 
    'goo' => 'goovalue', 
    'moo' => 'moovalue', 
    'zoo' => 'zoovalue' 
); 

getAdjascentKey('goo', $myhash, +1); 
// moo 

getAdjascentKey('zoo', $myhash, +1); 
// false 

getAdjascentKey('foo', $myhash, -1); 
// false 

Answer 8

ampliar aún más en la solución de Luca Borrione y Cenk, de manera que se puede envolver alrededor de la final de la matriz en cualquier dirección, se pueden utilizar:

function getAdjascentKey($key, $hash = array(), $increment) { 
    $keys = array_keys($hash);  
    $found_index = array_search($key, $keys); 
    if ($found_index === min(array_keys($keys)) && $increment === -1) { 
     $found_index = max(array_keys($keys))+1; 
    } 
    if ($found_index === max(array_keys($keys)) && $increment === +1) { 
     $found_index = min(array_keys($keys))-1; 
    }  
    return $keys[$found_index+$increment]; 
}