Ca tine're de-a face cu o matrice de siruri de caractere, puteți utiliza pur și simplu array_filter(), convenabil care se ocupă de toate acestea pentru tine:

print_r(array_filter($linksArray));

Păstrați în minte că dacă nu callback este furnizat, toate intrările de matrice egale cu "FALS" (a se vedea de conversie a boolean) va fi eliminat. Deci, dacă aveți nevoie pentru a păstra elemente care sunt adică exact string'0', veți avea nevoie de un custom callback:

// PHP < 5.3
print_r(array_filter($linksArray, create_function('$value', 'return $value !== "";')));

// PHP 5.3 and later
print_r(array_filter($linksArray, function($value) { return !is_null($value) && $value !== ''; }));

Puteți utiliza array_filter pentru a elimina gol elemente:

$emptyRemoved = array_filter($linksArray);

Dacă aveți(int) 0` în matrice, se pot utiliza următoarele:

$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: Poate că elementele nu sunt goale per se, dar conține unul sau mai multe spatii... puteți utiliza următoarele înainte de a utiliza array_filter

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

Cel mai popular răspuns pe acest subiect este absolut INCORECT.

Luați în considerare următorul script PHP:

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

De ce este acest lucru? Pentru un șir care conține o singur '0' caracter, de asemenea, se evaluează la boolean false, astfel încât, chiar dacă-l's nu un șir gol, se va obține încă se filtrează. Asta ar fi un bug.

Trecerea built-in funcția strlen ca funcția de filtrare va funcționa, pentru că ea returnează non-zero întreg pentru un non-empty string, și un zero întreg pentru un șir gol. Non-zero întregi întotdeauna evalua la true atunci când sunt convertite la boolean, în timp ce zero întregi întotdeauna evaluează la false atunci când sunt convertite la boolean.

Deci, absolută, definitivă, răspunsul corect este:

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

$linksArray = array_filter($linksArray);

"Dacă nu callback este furnizat, toate intrările de intrare egală cu FALSE vor fi eliminate." -- http://php.net/manual/en/function.array-filter.php

Puteți face doar

array_filter($array)

array_filter: "Dacă nu callback este furnizat, toate intrările de intrare egală cu FALSE vor fi eliminate." Acest lucru înseamnă că elementele cu valori NULL, 0, '0', '', FALS, array() va fi eliminat prea.

Cealaltă opțiune este de a face

array_diff($array, array(''))

care va elimina elementele cu valori NULL, '' și FALS.

Sper că acest lucru ajută :)

ACTUALIZARE

Aici este un exemplu.

$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())

Pentru a rezuma:

• 0 sau '0' va elimina 0 si '0'
• NULL, FALSE sau '' va elimina NULL, FALSE și ''

O altă linie pentru a elimina gol ("" șir gol) elemente din matrice.

$array = array_filter($array, function($a) {return $a !== "";});

Nota: Acest cod ține în mod deliberat nul, 0 și fals elemente.

Sau poate vrei să-ți tai elementele de matrice în primul rând:

$array = array_filter($array, function($a) {
    return trim($a) !== "";
});

Nota: Acest cod elimină, de asemenea, null și fals elemente.

Pe scurt:

Acest lucru este meu a sugerat cod:

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

Explicatie:

Am crede că utilizarea array_filter e bun, dar nu suficient, pentru că valorile fi o astfel de "spațiu" și\n`,... ține în matrice și acest lucru este, de obicei rău.

Așa că îți sugerez să utilizați amestec array_filter " și " array_map.

array_map este pentru tunderea, array_filter este pentru a elimina valorile goale, strlen este pentru 0 valoare, și array_values e de re de indexare, dacă este necesar.

Probe:

$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);

Rezultate:

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

Dacă lucrați cu un număr de serie și trebuie să re-index array după eliminarea gol elemente, utilizați array_values funcție:

array_values(array_filter($array));

Vezi, de asemenea: https://stackoverflow.com/questions/7558022/php-reindex-array

Cel mai votat răspuns este greșit sau cel puțin nu complet adevarat ca OP este vorba despre gol doar siruri de caractere. Aici's o explicație detaliată:

Ce empty spun?

Mai întâi de toate, trebuie să cădem de acord asupra a ceea ce gol mijloace. Adică să filtreze:

1. la siruri de caractere goale numai ("")?
2. la strict false valori? ($element === false)
3. la falsey valori? (adică 0, 0.0, "", "0", NULL, array()...)
4. echivalentul de PHP's gol() funcția?

Cum te filtra valorile

Pentru a filtra siruri de caractere goale numai:

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

La numai filtra strict fals valorile, trebuie să utilizați un callback funcția:

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

Apel invers este, de asemenea, util pentru orice combinație în care doriți pentru a filtra "falsey" valorile, cu excepția unora. (De exemplu, filtrul la fiecare nul și fals, etc, lăsând numai "0"):

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

Al treilea și al patrulea caz sunt (pentru scopurile noastre la ultima) echivalent, și pentru că toate trebuie să utilizați este implicit:

$filtered = array_filter($originalArray);

Am avut de a face acest lucru în scopul de a menține o valoare matrice de (string) 0

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

Pentru matrice multidimensionale

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

Eu folosesc următorul script pentru a elimina gol elemente dintr-o matrice

for ($i=0; $i

Vreau doar să contribuie o alternativă la bucle..., de asemenea, abordarea lacunelor în cheile...

În cazul meu, am vrut să păstreze secvențială matrice a tastelor atunci când operațiunea a fost completă (nu doar numere impare, care este ceea ce mă uitam la. Setarea codului pentru a arata la fel de ciudat cheile părea fragilă la mine și nu la viitor-friendly.)

Am fost în căutarea pentru ceva mai mult ca asta: http://gotofritz.net/blog/howto/removing-empty-array-elements-php/

Combinația de array_filter și array_slice face truc.

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

Nici o idee despre eficiența sau repere, dar funcționează.

$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>';
} 

ieșire

1:5

2:6