Implodieren Sie ein Array mit "," und fügen Sie "und" vor dem letzten Element hinzu

Dieses Array enthält eine Liste von Elementen, und ich möchte daraus eine Zeichenfolge machen, aber ich weiß nicht, wie das letzte Element ein & / und davor anstelle eines Kommas haben soll.

1 => coke 2=> sprite 3=> fanta

soll werden

coke, sprite and fanta

Dies ist die reguläre implodierende Funktion:

$listString = implode(', ', $listArrau);

Was ist ein einfacher Weg, um es zu tun?

Ein Longliner, der mit einer beliebigen Anzahl von Artikeln funktioniert:

echo join(' and ', array_filter(array_merge(array(join(', ', array_slice($array, 0, -1))), array_slice($array, -1)), 'strlen'));

Oder wenn Sie die Ausführlichkeit wirklich bevorzugen:

$last  = array_slice($array, -1);
$first = join(', ', array_slice($array, 0, -1));
$both  = array_filter(array_merge(array($first), $last), 'strlen');
echo join(' and ', $both);

Der Punkt ist, dass dieses Schneiden, Zusammenführen, Filtern und Verbinden alle Fälle, einschließlich 0, 1 und 2 Elemente, ohne zusätzliche if..elseAnweisungen korrekt behandelt . Und es ist zufällig zu einem Einzeiler zusammenklappbar.

Ich bin mir nicht sicher, ob ein Einzeiler die eleganteste Lösung für dieses Problem ist.

Ich habe das vor einiger Zeit geschrieben und es nach Bedarf abgelegt:

/**
 * Join a string with a natural language conjunction at the end. 
 * https://gist.github.com/angry-dan/e01b8712d6538510dd9c
 */
function natural_language_join(array $list, $conjunction = 'and') {
  $last = array_pop($list);
  if ($list) {
    return implode(', ', $list) . ' ' . $conjunction . ' ' . $last;
  }
  return $last;
}

Sie müssen "und" nicht als Join-Zeichenfolge verwenden, es ist effizient und funktioniert mit 0 bis zu einer unbegrenzten Anzahl von Elementen:

// null
var_dump(natural_language_join(array()));
// string 'one'
var_dump(natural_language_join(array('one')));
// string 'one and two'
var_dump(natural_language_join(array('one', 'two')));
// string 'one, two and three'
var_dump(natural_language_join(array('one', 'two', 'three')));
// string 'one, two, three or four'
var_dump(natural_language_join(array('one', 'two', 'three', 'four'), 'or'));

Sie können das letzte Element einfügen und es dann mit dem Text verbinden:

$yourArray = ('a', 'b', 'c');
$lastItem = array_pop($yourArray); // c
$text = implode(', ', $yourArray); // a, b
$text .= ' and '.$lastItem; // a, b and c

Versuche dies:

$str = array_pop($array);
if ($array)
    $str = implode(', ', $array)." and ".$str;

Eine weitere mögliche kurze Lösung:

$values = array('coke', 'sprite', 'fanta');

$values[] = implode(' and ', array_splice($values, -2));
print implode(', ', $values);  // "coke, sprite and fanta"

Es funktioniert gut mit einer beliebigen Anzahl von Werten.

Ich weiß, ich bin viel zu spät für die Antwort, aber das ist sicherlich ein besserer Weg, es zu tun?

$list = array('breakfast', 'lunch', 'dinner');
$list[count($list)-1] = "and " . $list[count($list)-1];
echo implode(', ', $list);

Mein Ansprechpartner, ähnlich wie Enriques Antwort, behandelt aber optional das Oxford-Komma.

public static function listifyArray($array,$conjunction='and',$oxford=true) {
    $last = array_pop($array);
    $remaining = count($array);
    return ($remaining ?
        implode(', ',$array) . (($oxford && $remaining > 1) ? ',' : '') . " $conjunction "
        : '') . $last;
}

Dies kann mit array_fillund erfolgen array_map. Es ist auch ein Einzeiler (scheint, dass viele sie genießen), aber für die Lesbarkeit formatiert:

$string = implode(array_map(
    function ($item, $glue) { return $item . $glue; }, 
    $array,
    array_slice(array_fill(0, count($array), ', ') + ['last' => ' and '], 2)
));

Nicht die optimalste Lösung, aber dennoch.

Hier ist die Demo .

Versuche dies

$arr = Array("coke","sprite","fanta");
$str = "";
$lenArr = sizeof($arr);
for($i=0; $i<$lenArr; $i++)
{
    if($i==0)
        $str .= $arr[$i];
    else if($i==($lenArr-1))
        $str .= " and ".$arr[$i];
    else
        $str .= " , ".$arr[$i];
}
print_r($str);

Versuche dies,

<?php
$listArray = array("coke","sprite","fanta");

foreach($listArray as $key => $value)
{
 if(count($listArray)-1 == $key)
  echo "and " . $value;
 else if(count($listArray)-2 == $key)
  echo $value . " ";
 else
  echo $value . ", ";
}
?>

Ich habe dies nur anhand der Vorschläge auf dieser Seite codiert. Ich habe meinen Pseudocode in den Kommentaren hinterlassen, falls jemand ihn brauchte. Mein Code unterscheidet sich von anderen hier, da er Arrays unterschiedlicher Größe unterschiedlich behandelt und die Oxford-Komma-Notation für Listen mit drei oder mehr verwendet.

    /**
     * Create a comma separated list of items using the Oxford comma notation.  A
     * single item returns just that item.  2 array elements returns the items
     * separated by "and".  3 or more items return the comma separated list.
     *
     * @param array $items Array of strings to list
     * @return string List of items joined by comma using Oxford comma notation
     */
    function _createOxfordCommaList($items) {
        if (count($items) == 1) {
            // return the single name
            return array_pop($items);
        }
        elseif (count($items) == 2) {
            // return array joined with "and"
            return implode(" and ", $items);
        }
        else {
            // pull of the last item
            $last = array_pop($items);

            // join remaining list with commas
            $list = implode(", ", $items);

            // add the last item back using ", and"
            $list .= ", and " . $last;

            return $list;
        }
    }

Das ist zu diesem Zeitpunkt ziemlich alt, aber ich dachte, es kann nicht schaden, meine Lösung dem Stapel hinzuzufügen. Es ist ein bisschen mehr Code als andere Lösungen, aber damit bin ich einverstanden.

Ich wollte etwas mit ein wenig Flexibilität, deshalb habe ich eine Dienstprogrammmethode erstellt, mit der Sie festlegen können, wie das endgültige Trennzeichen aussehen soll (damit Sie beispielsweise ein kaufmännisches Und verwenden können) und ob ein Oxford-Komma verwendet werden soll oder nicht. Es behandelt auch Listen mit 0, 1 und 2 Elementen ordnungsgemäß (etwas, was einige der Antworten hier nicht tun)

$androidVersions = ['Donut', 'Eclair', 'Froyo', 'Gingerbread', 'Honeycomb', 'Ice Cream Sandwich', 'Jellybean', 'Kit Kat', 'Lollipop', 'Marshmallow'];

echo joinListWithFinalSeparator(array_slice($androidVersions, 0, 1)); // Donut
echo joinListWithFinalSeparator(array_slice($androidVersions, 0, 2)); // Donut and Eclair
echo joinListWithFinalSeparator($androidVersions); // Donut, Eclair, Froyo, Gingerbread, Honeycomb, Ice Cream Sandwich, Jellybean, Kit Kat, Lollipop, and Marshmallow
echo joinListWithFinalSeparator($androidVersions, '&', false); // Donut, Eclair, Froyo, Gingerbread, Honeycomb, Ice Cream Sandwich, Jellybean, Kit Kat, Lollipop & Marshmallow

function joinListWithFinalSeparator(array $arr, $lastSeparator = 'and', $oxfordComma = true) {
    if (count($arr) > 1) {
        return sprintf(
            '%s%s %s %s', 
            implode(', ', array_slice($arr, 0, -1)),
            $oxfordComma && count($arr) > 2 ? ',':'',
            $lastSeparator ?: '', 
            array_pop($arr)
        );
    }

    // not a fan of this, but it's the simplest way to return a string from an array of 0-1 items without warnings
    return implode('', $arr);
}

OK, das wird also ziemlich alt, aber ich muss sagen, ich denke, die meisten Antworten sind sehr ineffizient mit mehreren Imploden oder Array-Zusammenführungen und ähnlichen Dingen, die alle weitaus komplexer sind als nötig, IMO.

Warum nicht einfach:

implode(',', array_slice($array, 0, -1)) . ' and ' . array_slice($array, -1)[0]

Einfacher human_implode mit Regex.

function human_implode($glue = ",", $last = "y", $elements = array(), $filter = null){
    if ($filter) {
        $elements = array_map($filter, $elements);
    }

    $str = implode("{$glue} ", $elements);

    if (count($elements) == 2) {
        return str_replace("{$glue} ", " {$last} ", $str);
    }

   return preg_replace("/[{$glue}](?!.*[{$glue}])/", " {$last}", $str);
}

print_r(human_implode(",", "and", ["Joe","Hugh", "Jack"])); // => Joe, Hugh and Jack

Eine andere, wenn auch etwas ausführlichere Lösung, die ich mir ausgedacht habe. In meiner Situation wollte ich die Wörter im Array Plural machen, daher wird am Ende jedes Elements ein "s" hinzugefügt (es sei denn, das Wort endet bereits mit "s":

$models = array("F150","Express","CR-V","Rav4","Silverado");
foreach($models as $k=>$model){ 
    echo $model;
    if(!preg_match("/s|S$/",$model)) 
        echo 's'; // add S to end (if it doesn't already end in S)
    if(isset($models[$k+1])) { // if there is another after this one.
        echo ", "; 
        if(!isset($models[$k+2])) 
            echo "and "; // If this is next-to-last, add  ", and" 
        }
    }
}

Ausgänge:

F150s, Express, CR-Vs, Rav4s, and Silverados

Es ist schneller als die Lösung von deceze und funktioniert mit riesigen Arrays (1M + Elemente). Der einzige Fehler beider Lösungen ist eine schlechte Interaktion mit einer Zahl 0 in Arrays mit weniger als drei Elementen, da array_filter verwendet wird.

echo implode(' and ', array_filter(array_reverse(array_merge(array(array_pop($array)), array(implode(', ',$array))))));