Laravel 5

problème de erreur de syntaxe Parse error: syntax error, unexpected '=' in C:\laragon\www\gestion-audience\vendor\laravel\framework\src\Illuminate\Support\Arr.php on line 384

  • Avatar de Nchanjepaularmel
    Membre depuis :
    23/08/2019
    Messages :
    4

    bonjour a tous je suis nouveau dans le forum
    j'ai un soucis la commande php artisan sur mon projet
    quand je redige le comment php artisan sur mon terminale ça me revoie le massage d'erreur suivant:

    Parse error: syntax error, unexpected '=' in C:\laragon\www\gestion-audience\vendor\laravel\framework\src\Illuminate\Support\Arr.php on line 384
    comment faire SVP aidé moi petite présition
    je suis débutant
    merci

  • Avatar de CinquièmeDimension
    Membre depuis :
    18/04/2019
    Messages :
    31

    Salut,

    Si tu fais un petit php -v dans ta console ca te renvoie quelle version de PHP ?

  • Avatar de Nchanjepaularmel
    Membre depuis :
    23/08/2019
    Messages :
    4

    ça me renvoi le php 7.2.19

  • Avatar de Nchanjepaularmel
    Membre depuis :
    23/08/2019
    Messages :
    4

    J'ai utiliser laragon pour installer laravel commencer mon projet

  • Avatar de Nchanjepaularmel
    Membre depuis :
    23/08/2019
    Messages :
    4

    <?php

    namespace Illuminate\Support;

    use ArrayAccess;
    use InvalidArgumentException;
    use Illuminate\Support\Traits\Macroable;

    class Arr
    {
    use Macroable;

    /
    Determine whether the given value is array accessible.

    @param mixed $value
    @return bool
    */
    public static function accessible($value)
    {
    return is_array($value) || $value instanceof ArrayAccess;
    }

    /*
    Add an element to an array using "dot" notation if it doesn't exist.

    @param array $array
    @param string $key
    @param mixed $value
    @return array
    /
    public static function add($array, $key, $value)
    {
    if (is_null(static::get($array, $key))) {
    static::set($array, $key, $value);
    }

    return $array;
    }

    /

    Collapse an array of arrays into a single array.

    @param array $array
    @return array
    */
    public static function collapse($array)
    {
    $results = [];

    foreach ($array as $values) {
    if ($values instanceof Collection) {
    $values = $values->all();
    } elseif (! is_array($values)) {
    continue;
    }

    $results[] = $values;
    }

    return array_merge([], ...$results);
    }

    /
    Cross join the given arrays, returning all possible permutations.

    @param array ...$arrays
    @return array
    */
    public static function crossJoin(...$arrays)
    {
    $results = [[]];

    foreach ($arrays as $index => $array) {
    $append = [];

    foreach ($results as $product) {
    foreach ($array as $item) {
    $product[$index] = $item;

    $append[] = $product;
    }
    }

    $results = $append;
    }

    return $results;
    }

    /*
    Divide an array into two arrays. One with keys and the other with values.

    @param array $array
    @return array
    /
    public static function divide($array)
    {
    return [array_keys($array), array_values($array)];
    }

    /

    Flatten a multi-dimensional associative array with dots.

    @param array $array
    @param string $prepend
    @return array
    /
    public static function dot($array, $prepend = '')
    {
    $results = [];

    foreach ($array as $key => $value) {
    if (is_array($value) && ! empty($value)) {
    $results = array_merge($results, static::dot($value, $prepend.$key.'.'));
    } else {
    $results[$prepend.$key] = $value;
    }
    }

    return $results;
    }

    /
    Get all of the given array except for a specified array of keys.

    @param array $array
    @param array|string $keys
    @return array
    /
    public static function except($array, $keys)
    {
    static::forget($array, $keys);

    return $array;
    }

    /

    Determine if the given key exists in the provided array.

    @param \ArrayAccess|array $array
    @param string|int $key
    @return bool
    /
    public static function exists($array, $key)
    {
    if ($array instanceof ArrayAccess) {
    return $array->offsetExists($key);
    }

    return array_key_exists($key, $array);
    }

    /
    Return the first element in an array passing a given truth test.

    @param array $array
    @param callable|null $callback
    @param mixed $default
    @return mixed
    */
    public static function first($array, callable $callback = null, $default = null)
    {
    if (is_null($callback)) {
    if (empty($array)) {
    return value($default);
    }

    foreach ($array as $item) {
    return $item;
    }
    }

    foreach ($array as $key => $value) {
    if (call_user_func($callback, $value, $key)) {
    return $value;
    }
    }

    return value($default);
    }

    /*
    Return the last element in an array passing a given truth test.

    @param array $array
    @param callable|null $callback
    @param mixed $default
    @return mixed
    /
    public static function last($array, callable $callback = null, $default = null)
    {
    if (is_null($callback)) {
    return empty($array) ? value($default) : end($array);
    }

    return static::first(array_reverse($array, true), $callback, $default);
    }

    /

    Flatten a multi-dimensional array into a single level.

    @param array $array
    @param int $depth
    @return array
    /
    public static function flatten($array, $depth = INF)
    {
    $result = [];

    foreach ($array as $item) {
    $item = $item instanceof Collection ? $item->all() : $item;

    if (! is_array($item)) {
    $result[] = $item;
    } else {
    $values = $depth === 1
    ? array_values($item)
    : static::flatten($item, $depth - 1);

    foreach ($values as $value) {
    $result[] = $value;
    }
    }
    }

    return $result;
    }

    /
    Remove one or many array items from a given array using "dot" notation.

    @param array $array
    @param array|string $keys
    @return void
    /
    public static function forget(&$array, $keys)
    {
    $original = &$array;

    $keys = (array) $keys;

    if (count($keys) === 0) {
    return;
    }

    foreach ($keys as $key) {
    // if the exact key exists in the top-level, remove it
    if (static::exists($array, $key)) {
    unset($array[$key]);

    continue;
    }

    $parts = explode('.', $key);

    // clean up before each pass
    $array = &$original;

    while (count($parts) > 1) {
    $part = array_shift($parts);

    if (isset($array[$part]) && is_array($array[$part])) {
    $array = &$array[$part];
    } else {
    continue 2;
    }
    }

    unset($array[array_shift($parts)]);
    }
    }

    /

    Get an item from an array using "dot" notation.

    @param \ArrayAccess|array $array
    @param string|int $key
    @param mixed $default
    @return mixed
    */
    public static function get($array, $key, $default = null)
    {
    if (! static::accessible($array)) {
    return value($default);
    }

    if (is_null($key)) {
    return $array;
    }

    if (static::exists($array, $key)) {
    return $array[$key];
    }

    if (strpos($key, '.') === false) {
    return $array[$key] ?? value($default);
    }

    foreach (explode('.', $key) as $segment) {
    if (static::accessible($array) && static::exists($array, $segment)) {
    $array = $array[$segment];
    } else {
    return value($default);
    }
    }

    return $array;
    }

    /
    Check if an item or items exist in an array using "dot" notation.

    @param \ArrayAccess|array $array
    @param string|array $keys
    @return bool
    /
    public static function has($array, $keys)
    {
    $keys = (array) $keys;

    if (! $array || $keys === []) {
    return false;
    }

    foreach ($keys as $key) {
    $subKeyArray = $array;

    if (static::exists($array, $key)) {
    continue;
    }

    foreach (explode('.', $key) as $segment) {
    if (static::accessible($subKeyArray) && static::exists($subKeyArray, $segment)) {
    $subKeyArray = $subKeyArray[$segment];
    } else {
    return false;
    }
    }
    }

    return true;
    }

    /

    Determines if an array is associative.

    An array is "associative" if it doesn't have sequential numerical keys beginning with zero.

    @param array $array
    @return bool
    */
    public static function isAssoc(array $array)
    {
    $keys = array_keys($array);

    return array_keys($keys) !== $keys;
    }

    /
    Get a subset of the items from the given array.

    @param array $array
    @param array|string $keys
    @return array
    /
    public static function only($array, $keys)
    {
    return array_intersect_key($array, array_flip((array) $keys));
    }

    /

    Pluck an array of values from an array.

    @param array $array
    @param string|array $value
    @param string|array|null $key
    @return array
    */
    public static function pluck($array, $value, $key = null)
    {
    $results = [];

    [$value, $key] = static::explodePluckParameters($value, $key); // c'est cette ligne qui est soulignié et qui cause ce problème la

    foreach ($array as $item) {
    $itemValue = data_get($item, $value);

    // If the key is "null", we will just append the value to the array and keep
    // looping. Otherwise we will key the array using the value of the key we
    // received from the developer. Then we'll return the final array form.
    if (is_null($key)) {
    $results[] = $itemValue;
    } else {
    $itemKey = data_get($item, $key);

    if (is_object($itemKey) && method_exists($itemKey, '__toString')) {
    $itemKey = (string) $itemKey;
    }

    $results[$itemKey] = $itemValue;
    }
    }

    return $results;
    }

    /
    Explode the "value" and "key" arguments passed to "pluck".

    @param string|array $value
    @param string|array|null $key
    @return array
    /
    protected static function explodePluckParameters($value, $key)
    {
    $value = is_string($value) ? explode('.', $value) : $value;

    $key = is_null($key) || is_array($key) ? $key : explode('.', $key);

    return [$value, $key];
    }

    /

    Push an item onto the beginning of an array.

    @param array $array
    @param mixed $value
    @param mixed $key
    @return array
    */
    public static function prepend($array, $value, $key = null)
    {
    if (is_null($key)) {
    array_unshift($array, $value);
    } else {
    $array = [$key => $value] + $array;
    }

    return $array;
    }

    /
    Get a value from the array, and remove it.

    @param array $array
    @param string $key
    @param mixed $default
    @return mixed
    */
    public static function pull(&$array, $key, $default = null)
    {
    $value = static::get($array, $key, $default);

    static::forget($array, $key);

    return $value;
    }

    /
    Get one or a specified number of random values from an array.

    @param array $array
    @param int|null $number
    @return mixed

    @throws \InvalidArgumentException
    /
    public static function random($array, $number = null)
    {
    $requested = is_null($number) ? 1 : $number;

    $count = count($array);

    if ($requested > $count) {
    throw new InvalidArgumentException(
    "You requested {$requested} items, but there are only {$count} items available."
    );
    }

    if (is_null($number)) {
    return $array[array_rand($array)];
    }

    if ((int) $number === 0) {
    return [];
    }

    $keys = array_rand($array, $number);

    $results = [];

    foreach ((array) $keys as $key) {
    $results[] = $array[$key];
    }

    return $results;
    }

    /

    Set an array item to a given value using "dot" notation.

    If no key is given to the method, the entire array will be replaced.

    @param array $array
    @param string $key
    @param mixed $value
    @return array
    */
    public static function set(&$array, $key, $value)
    {
    if (is_null($key)) {
    return $array = $value;
    }

    $keys = explode('.', $key);

    while (count($keys) > 1) {
    $key = array_shift($keys);

    // If the key doesn't exist at this depth, we will just create an empty array
    // to hold the next value, allowing us to create the arrays to hold final
    // values at the correct depth. Then we'll keep digging into the array.
    if (! isset($array[$key]) || ! is_array($array[$key])) {
    $array[$key] = [];
    }

    $array = &$array[$key];
    }

    $array[array_shift($keys)] = $value;

    return $array;
    }

    /

    Shuffle the given array and return the result.

    @param array $array
    @param int|null $seed
    @return array
    /
    public static function shuffle($array, $seed = null)
    {
    if (is_null($seed)) {
    shuffle($array);
    } else {
    mt_srand($seed);
    shuffle($array);
    mt_srand();
    }

    return $array;
    }

    /
    Sort the array using the given callback or "dot" notation.

    @param array $array
    @param callable|string|null $callback
    @return array
    /
    public static function sort($array, $callback = null)
    {
    return Collection::make($array)->sortBy($callback)->all();
    }

    /

    Recursively sort an array by keys and values.

    @param array $array
    @return array
    */
    public static function sortRecursive($array)
    {
    foreach ($array as &$value) {
    if (is_array($value)) {
    $value = static::sortRecursive($value);
    }
    }

    if (static::isAssoc($array)) {
    ksort($array);
    } else {
    sort($array);
    }

    return $array;
    }

    /*
    Convert the array into a query string.

    @param array $array
    @return string
    /
    public static function query($array)
    {
    return http_build_query($array, null, '&', PHP_QUERY_RFC3986);
    }

    /
    Filter the array using the given callback.

    @param array $array
    @param callable $callback
    @return array
    /
    public static function where($array, callable $callback)
    {
    return array_filter($array, $callback, ARRAY_FILTER_USE_BOTH);
    }

    /

    If the given value is not an array and not null, wrap it in one.

    @param mixed $value
    @return array
    */
    public static function wrap($value)
    {
    if (is_null($value)) {
    return [];
    }

    return is_array($value) ? $value : [$value];
    }

    }

  • Avatar de CinquièmeDimension
    Membre depuis :
    18/04/2019
    Messages :
    31

    Tu as touché à ce fichier ?
    De manière générale il ne faut jamais toucher à ce qu'il y a dans \vendor.

    C'est vrai que plusieurs forums parlent de la version de php pour cette erreur. Notemment du fait que ton serveur puisse utiliser une version differente mais avec laragon je ne pense pas que ce soit le cas...

    Tu peux essayer de suprimer ton dossier vendor (ou plutôt de le renommer pour éviter de faire une connerie) et de le recréer avec un composer install

    Voyons déjà si ca fait avancer l'affaire...

    Je ne connais pas Laragon, moi, donc je ne saurais pas trop comment t'aider plus.

Vous ne pouvez pas répondre à ce sujet.