Możesz użyć array_filter aby usunąć puste elementy:

$emptyRemoved = array_filter($linksArray);

Jeśli masz (int) 0 w swojej tablicy, możesz użyć:

$emptyRemoved = remove_empty($linksArray);

function remove_empty($array) {
  return array_filter($array, '_remove_empty_internal');
}

function _remove_empty_internal($value) {
  return !empty($value) || $value === 0;
}

EDIT: Może twoje elementy nie są puste per se, ale zawierają jedną lub więcej spacji... Możesz użyć następujących przed użyciem array_filter

$trimmedArray = array_map('trim', $linksArray);

$linksArray = array_filter($linksArray);

"Jeśli nie zostanie podane wywołanie zwrotne, wszystkie wpisy o wartości FALSE zostaną usunięte."-- http://php.net/manual/en/function.array-filter.php

Najpopularniejsza odpowiedź na ten temat jest absolutnie błędna.

Rozważ następujący skrypt PHP:

<?php
$arr = array('1', '', '2', '3', '0');
// Incorrect:
print_r(array_filter($arr));
// Correct:
print_r(array_filter($arr, 'strlen'));

Przekazanie wbudowanej funkcji strlen jako funkcji filtrującej będzie działać, ponieważ zwraca niezerową liczbę całkowitą dla niepustego ciągu, a zero całkowitą dla pusty ciąg. Niezerowe liczby całkowite zawsze oceniają na true po przekonwertowaniu na wartość logiczną, podczas gdy zerowe liczby całkowite zawsze oceniają na false po przekonwertowaniu na wartość logiczną.

$arr = array_filter($arr, 'strlen');

    $myarray = array_filter($myarray, 'strlen');  //removes null values but leaves "0"
    $myarray = array_filter($myarray);            //removes all null values

You can just do

array_filter($array)

Array_filter: "jeśli nie zostanie podane wywołanie zwrotne, wszystkie wpisy o wartości FALSE zostaną usunięte."Oznacza to, że elementy o wartościach NULL, 0, '0',", FALSE, array () również zostaną usunięte.

Inną opcją jest robienie

array_diff($array, array(''))

Który usunie elementy o wartościach NULL, " oraz FALSE.

Mam nadzieję, że to pomoże:)

UPDATE

$a = array(0, '0', NULL, FALSE, '', array());

var_dump(array_filter($a));
// array()

var_dump(array_diff($a, array(0))) // 0 / '0'
// array(NULL, FALSE, '', array());

var_dump(array_diff($a, array(NULL))) // NULL / FALSE / ''
// array(0, '0', array())

Podsumowując:

• 0 lub ' 0 ' usunie 0 i '0'
• NULL, FALSE lub "usunie NULL, FALSE i"

foreach($linksArray as $key => $link) 
{ 
    if($link === '') 
    { 
        unset($linksArray[$key]); 
    } 
} 
print_r($linksArray); 

Kolejny liner usuwający puste (""empty string) elementy z tablicy.

$array = array_filter($array, create_function('$a','return $a!=="";'));

Uwaga: Ten kod celowo zachowuje elementy null, 0 I false.

A może chcesz najpierw przyciąć elementy tablicy:

$array = array_filter($array, create_function('$a','return trim($a)!=="";'));

Uwaga: Ten kod usuwa również elementy null I false.

Jeśli pracujesz z tablicą numeryczną i musisz ponownie indeksować tablicę po usunięciu pustych elementów, użyj array_values Funkcja:

array_values(array_filter($array));

Zobacz też: tablica reindex PHP?

Najczęściej głosowana odpowiedź jest zła lub przynajmniej nie do końca prawdziwa, ponieważ OP mówi tylko o pustych strunach. Oto dokładne wyjaśnienie:

Co oznacza pusty ?

Przede wszystkim musimy się zgodzić co oznacza pusty . Czy chcesz odfiltrować:

1. the empty strings only ("")?
2. ściśle fałszywe wartości? ($element === false)
3. wartości false ? (tj. 0, 0, 0, "", "0", NULL, array()...)
4. odpowiednik empty() funkcji PHP?

Jak odfiltrować wartości

Aby odfiltrować tylko puste ciągi :

$filtered = array_diff($originalArray, array(""));

Aby odfiltrować tylko ściśle false wartości, musisz użyć funkcji callback:

$filtered = array_diff($originalArray, 'myCallback');
function myCallback($var) {
    return $var === false;
}

Wywołanie zwrotne jest również przydatne dla dowolnej kombinacji, w której chcesz odfiltrować wartości "falsey", z wyjątkiem niektórych. (Na przykład filtruj co null i false, itp, pozostawiając tylko 0):

$filtered = array_filter($originalArray, 'myCallback');
function myCallback($var) {
    return ($var === 0 || $var === '0');
}

Trzeci i czwarty przypadek są (dla naszych celów w końcu) równoważne, a do tego wszystko, co musisz użyć, to domyślne:

$filtered = array_filter($originalArray);

$a = array(1, '', '', '', 2, '', 3, 4);
$b = array_values(array_filter($a));

print_r($b)

Używam poniższego skryptu do usuwania pustych elementów z tablicy

for ($i=0; $i<$count($Array); $i++)
  {
    if (empty($Array[$i])) unset($Array[$i]);
  }

Dla tablicy wielowymiarowej

$data = array_map('array_filter', $data);
$data = array_filter($data);

Musiałem to zrobić, aby zachować wartość tablicy (string) 0

$url = array_filter($data, function ($value) {
  return (!empty($value) || $value === 0 || $value==='0');
});

W skrócie:

To jest mój sugerowany kod:

$myarray =  array_values(array_filter(array_map('trim', $myarray), 'strlen'));

Wyjaśnienie:

Myślę, że użycie array_filter jest dobre, ale nie wystarczające, ponieważ wartości są takie jak space i \n,... trzymaj w tablicy i to jest zwykle złe.

Więc sugeruję użycie mieszanki array_filter i array_map.

array_map jest do przycinania, {[3] } jest do usuwania pustych wartości, strlen jest do przechowywania 0 wartość, a array_values jest do ponownego indeksowania, jeśli potrzebne.

Próbki:

$myarray = array("\r", "\n", "\r\n", "", " ", "0", "a");

// "\r", "\n", "\r\n", " ", "a"
$new1 = array_filter($myarray);

// "a"
$new2 = array_filter(array_map('trim', $myarray));

// "0", "a"
$new3 = array_filter(array_map('trim', $myarray), 'strlen');

// "0", "a" (reindex)
$new4 = array_values(array_filter(array_map('trim', $myarray), 'strlen'));

var_dump($new1, $new2, $new3, $new4);

Wyniki:

array(5) {
  [0]=>
" string(1) "
  [1]=>
  string(1) "
"
  [2]=>
  string(2) "
"
  [4]=>
  string(1) " "
  [6]=>
  string(1) "a"
}
array(1) {
  [6]=>
  string(1) "a"
}
array(2) {
  [5]=>
  string(1) "0"
  [6]=>
  string(1) "a"
}
array(2) {
  [0]=>
  string(1) "0"
  [1]=>
  string(1) "a"
}

Test Online:

Http://phpio.net/s/5yg0

$out_array = array_filter($input_array, function($item) 
{ 
    return !empty($item['key_of_array_to_check_whether_it_is_empty']); 
}
);

Po prostu chcę stworzyć alternatywę dla pętli...również usuwanie luk w kluczach...

W moim przypadku chciałem zachować sekwencyjne klawisze tablicy po zakończeniu operacji (nie tylko liczby nieparzyste, na co patrzyłem. Ustawienie kodu, aby szukać tylko dziwnych kluczy, wydawało mi się kruche i nie przyjazne dla przyszłości.)

Szukałem czegoś bardziej podobnego: http://gotofritz.net/blog/howto/removing-empty-array-elements-php/

Kombinacja array_filter i array_slice załatwiają sprawę.

$example = array_filter($example); $example = array_slice($example,0);

Brak pomysłu na wydajność lub benchmarki, ale to działa.

function trim_array($Array)
{
    foreach ($Array as $value) {
        if(trim($value) === '') {
            $index = array_search($value, $Array);
            unset($Array[$index]);
        }
    }
    return $Array;
}

foreach($arr as $key => $val){
   if (empty($val)) unset($arr[$key];
}

Użyj funkcji array_filter, Aby usunąć puste wartości:

$linksArray = array_filter($linksArray);
print_r($linksArray);

Tylko jedna linijka : Aktualizacja (Dzięki @ suther):

$array_without_empty_values = array_filter($array);

$my = ("0"=>" ","1"=>"5","2"=>"6","3"=>" ");   

foreach ($my as $key => $value) {
    if (is_null($value)) unset($my[$key]);
}

foreach ($my as $key => $value) {
    echo   $key . ':' . $value . '<br>';
} 

Output

1:5

2:6

Usuń puste elementy tablicy

function removeEmptyElements(&$element)
{
    if (is_array($element)) {
        if ($key = key($element)) {
            $element[$key] = array_filter($element);
        }

        if (count($element) != count($element, COUNT_RECURSIVE)) {
            $element = array_filter(current($element), __FUNCTION__);
        }

        return $element;
    } else {
        return empty($element) ? false : $element;
    }
}

$data = array(
    'horarios' => array(),
    'grupos' => array(
        '1A' => array(
            'Juan' => array(
                'calificaciones' => array(
                    'Matematicas' => 8,
                    'Español' => 5,
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => 20,
                    'febrero' => 10,
                    'marzo' => '',
                )
            ),
            'Damian' => array(
                'calificaciones' => array(
                    'Matematicas' => 10,
                    'Español' => '',
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => 20,
                    'febrero' => '',
                    'marzo' => 5,
                )
            ),
        ),
        '1B' => array(
            'Mariana' => array(
                'calificaciones' => array(
                    'Matematicas' => null,
                    'Español' => 7,
                    'Ingles' => 9,
                ),
                'asistencias' => array(
                    'enero' => null,
                    'febrero' => 5,
                    'marzo' => 5,
                )
            ),
        ),
    )
);

$data = array_filter($data, 'removeEmptyElements');
var_dump($data);

Spróbuj tego. ** ** Przykład

$or = array(
        'PersonalInformation.first_name' => $this->request->data['User']['first_name'],
        'PersonalInformation.last_name' => $this->request->data['User']['last_name'],
        'PersonalInformation.primary_phone' => $this->request->data['User']['primary_phone'],
        'PersonalInformation.dob' => $this->request->data['User']['dob'],
        'User.email' => $this->request->data['User']['email'],
    );



 $or = array_filter($or);

    $condition = array(
        'User.role' => array('U', 'P'),
        'User.user_status' => array('active', 'lead', 'inactive'),
        'OR' => $or
    );

Zgodnie z metodą, możesz po prostu złapać te elementy w innej tablicy i użyć tej w następujący sposób,

foreach($linksArray as $link){
   if(!empty($link)){
      $new_arr[] = $link
   }
}

print_r($new_arr);