PHP: cómo conseguir elemento de matriz con clave como

1

Uso array_slice: http://php.net/manual/en/function.array-slice.php si solo desea seleccionar las claves conocidas. Aquí tienes la solución para las matrices de filtrado mediante teclas: PHP: How to use array_filter() to filter array keys?

Fuente

2012-08-13 11:28:13

8

Prueba esto:

$filtred = array(); 

foreach($yourArray as $key => $value) 
    if(preg_match('/c_\d/',$key)) 
    $filtred[] = $value; 

print_r($filtred);

Fuente

2012-08-13 11:28:46 Oussama

+0

Solución agradable y económica. –

+1

Creo que array_filter() es una mejor solución. – Robert

2

Usted puede intentar usar array_filter().

Hay algunos ejemplos interesantes en el php documentation page. Uno de ellos cubre el filtrado de teclas de matriz.

Fuente

2012-08-13 11:29:57

3

intenta esto

//your array 
    $arr1 = array (
      "y" => 35, 
      "x" => 51, 
      "z" => 35, 
      "c_3" => 4, 
      "c_1" => 54, 
      "c_6" => 53, 
      "c_9" => 52 
    ); 
// Array with keys you want 
    $arr2 = array (
      "c_3" => '', 
      "c_1" => '', 
      "c_6" => '', 
      "c_9" => '' 
    ); 
//use array_intersect_key to find the common ;) 
    print_r(array_intersect_key($arr1,$arr2));

Fuente

2012-08-13 11:59:05 Champ

+0

Bien, no sabía ese comando. Para quién quiere más información sobre array_intersect_key: http://php.net/manual/en/function.array-intersect-key.php –

1

que en realidad tenía pregunta y puesto de observación similar para las respuestas aquí, pero nada realmente emparejado mis expectativas.

quería algo más reutilizables que podría utilizar en todos mis proyectos, por lo que terminó escribiendo esta función:

/** 
* Create a new a array containing only the key with a certain $pattern or $subString. 
* 
* Note: You cannot use both $subString and $pattern at once ($substring has precedence on $pattern). 
* 
* @param $errorMessage String to return the error message. 
* @param $source Array in which we must extract data. 
* @param $subString String/Int/Array substring (or array of substring) to seek in the key name. 
* @param $pattern String regex for validating the key. 
* @param $useValueAsKey Boolean if true it will use the value as the key in the new array (scalar values only). 
*/ 
public static function extractSubArray(&$errorMessage, array &$source, $subString ="", $pattern = "", $useValueAsKey=false){ 

    $newArray = array(); 

    $errorMessage = ""; 

    $dbManager = GeneralDbManager::getInstance(); 

    if (empty($source)){ 

     $errorMessage = $dbManager->getErrorMessage("SOURCE_ARRAY_IS_EMPTY_ERR", "The array supplied is empty."); 
    } 
    elseif(empty($subString) and empty($pattern)){ 

     $errorMessage = $dbManager->getErrorMessage("NO_SUBSTR_OR_PATTERN_ERR", "There are no substring or pattern to match the keys in the array."); 
    } 
    elseif (!empty($subString) and !(is_string($subString) or is_numeric($subString) or is_array($subString))){ 

     $errorMessage = $dbManager->getErrorMessage("INVALID_MATCH_SUBSTRING_ERR", "The substring you supplied to match the keys is invalid."); 
    } 
    elseif(!empty($pattern) and !RegularExpression::testRegex($pattern)){ 

     $errorMessage = $dbManager->getErrorMessage("INVALID_MATCH_PATTERN_ERR", "The regular expression you supplied to match the keys is invalid."); 
    } 
    else{ 

     foreach ($source as $key => $value){ 

      if (self::isKeyMatchSubstring($key, $subString, $pattern)){ 

       if ($useValueAsKey and (is_string($value) or is_numeric($value))){ 

        $newArray[$value] = $value;  
       } 
       else{ 

        $newArray[$key] = $value; 
       } 
      }  
     } 

     if (empty($newArray)){ 

      $errorMessage = $dbManager->getErrorMessage("INVALID_MATCH_PATTERN_ERR", "We were not able to match any keys in the array with the substring or the regular expression."); 
     } 
    } 

    unset($dbManager); 

    return $newArray; 
} 

/** 
* Validate that the $key contains the $substring (string or array) or match the $pattern. 
* 
* @param $key String to validate 
* @param $subString String/Int/Array containing the subString to seek. 
* @param $pattern String regex for validating the key. 
*/ 
private static function isKeyMatchSubstring($key, $subString, $pattern){ 

    $matched = false; 

    if (!empty($subString)){ 

     if (is_string($subString) or is_numeric($subString)){ 

      if(strpos(strtolower($key), strtolower($subString)) !== false){ 

       $matched = true;  
      } 
     } 
     else{ //array 

      foreach($subString as $testString){ 

       $matched = self::isKeyMatchSubstring($key, $testString, ""); 

       if ($matched){ 

        break; 
       } 
      } 
     } 
    } 
    elseif(!empty($pattern)){ 

     $matched = preg_match($pattern, $key); 
    } 

    return $matched; 
}

Se utiliza una función llamada testRegex(), así que supongo que puedo suministrar ese código también:

/** 
* Make sure that a regular expression works in PHP. 
* 
* @param $regex String the regular expression to validate. 
* 
* @return Boolean 
*/ 
public static function testRegex($regex){ 

    $isValid = false; 

    if (!empty($regex) and is_string($regex)){ 

     if (@preg_match($regex, null) !== false){ 
      $isValid = true; 
     } 
    } 

    return $isValid; 
}

Y, por supuesto, ¿qué tan bueno sería una función sin pruebas unitarias?

public function testExtractSubArray(){ 

    $errorMessage = ""; 

    $source = array(); 

    //no data 
    $this->assertEmpty(Tool::extractSubArray($errorMessage, $source, "", "", false)); 

    $this->assertNotEmpty($errorMessage); 

    //no substring or pattern 
    $source = array(1 => 1); 


    $this->assertEmpty(Tool::extractSubArray($errorMessage, $source, "", "", false)); 

    $this->assertNotEmpty($errorMessage); 


    //invalid substring 
    $dbmanager = GeneralDbManager::getInstance(); 

    $this->assertEmpty(Tool::extractSubArray($errorMessage, $source, $dbmanager, "", false)); 

    $this->assertNotEmpty($errorMessage); 

    unset($dbmanager); 


    //invalid pattern 
    $this->assertEmpty(Tool::extractSubArray($errorMessage, $source, "", "[]123", false)); 

    $this->assertNotEmpty($errorMessage); 


    //no match 
    $this->assertEmpty(Tool::extractSubArray($errorMessage, $source, "pokemon", "", false)); 

    $this->assertNotEmpty($errorMessage); 


    //valid substring 
    $source = array("woot1" => "homer", "woot2" => "bart", "woot3" => "lisa", "doh1" => "marge", "doh2" => "simpson"); 

    $newArray = Tool::extractSubArray($errorMessage, $source, "WOOT", "", false); 


    $this->assertNotEmpty($newArray); 

    $this->assertEmpty($errorMessage); 

    $this->assertContains("homer", $newArray); 

    $this->assertContains("bart", $newArray); 

    $this->assertContains("lisa", $newArray); 

    $this->assertNotContains("marge", $newArray); 

    $this->assertNotContains("simpson", $newArray); 


    //use value as key 
    $newArray = Tool::extractSubArray($errorMessage, $source, "WOOT", "", true); 


    $this->assertTrue(array_key_exists("homer", $newArray)); 

    $this->assertTrue(array_key_exists("bart", $newArray)); 

    $this->assertTrue(array_key_exists("lisa", $newArray)); 


    //substring array 
    $source = array("stan_march" => "normal", "kyle_brofloski" => "jew", "eric_cartman" => "asshole", "kenny_mccormick" => "dead", "butters_stotch" => "pushover"); 

    $newArray = Tool::extractSubArray($errorMessage, $source, array("stan", "kyle", "cartman"), "", false); 


    $this->assertNotEmpty($newArray); 

    $this->assertEmpty($errorMessage); 

    $this->assertContains("normal", $newArray); 

    $this->assertContains("jew", $newArray); 

    $this->assertContains("asshole", $newArray); 

    $this->assertNotContains("dead", $newArray); 

    $this->assertNotContains("pushover", $newArray); 


    //regex 
    $source = array("[email protected]" => 1, "jonathan" => 2, "12345" => 3, "more $$$" => 4, "$?%$?%$%?" => 5); 

    $newArray = Tool::extractSubArray($errorMessage, $source, "", RegularExpression::ALPHA_NUMERIC, false); 


    $this->assertNotEmpty($newArray); 

    $this->assertEmpty($errorMessage); 

    $this->assertNotContains(1, $newArray); 

    $this->assertContains(2, $newArray); 

    $this->assertContains(3, $newArray); 

    $this->assertNotContains(4, $newArray); 

    $this->assertNotContains(5, $newArray); 
}

nota adicional: Este código utiliza getErrorMessage() método se ha podido recuperar la traducción del mensaje de error en la base de datos. Como esos mensajes de error están destinados a la depuración, se pueden codificar directamente en el código para aumentar el rendimiento (no es necesario crear una instancia de la clase para recuperar el mensaje de error y abrir una conexión a la base de datos).

Bueno, espero que ayude a algunos fanáticos de la reutilización como yo.

Jonathan Padres-Lévesque de Montreal

Fuente

2015-08-12 19:35:54

2

Controlar esta solución con array_filter()

$arr = [ 
    'y' => 35, 
    'x' => 51, 
    'z' => 35, 
    'c_3' => 4, 
    'c_1' => 54, 
    'c_6' => 53, 
    'c_9' => 52, 
]; 

$filtered = array_filter($arr, function($v) use($arr){ 
    return preg_match('#c_\d#', array_search($v, $arr)); 
});

Solución continuación trabajará en PHP> = 5.6.0

$filtered = array_filter($arr, function($k){ 
    return preg_match('#c_\d#', $k); 
}, ARRAY_FILTER_USE_KEY);

Ambas soluciones trabajo que he los revisé

Fuente

2015-08-13 13:31:25 Robert

PHP: cómo conseguir elemento de matriz con clave como

Respuesta

Cuestiones relacionadas