PHP Function Array_Sum

PHP is a powerful language that allows web developers to create dynamic websites with ease. One of its most useful functions is the array_sum() function, which is used to calculate sums of array values. In this article, we will cover the basics and practical applications of this useful function.

Array_sum() is an inbuilt function in PHP that takes an input array as its parameter and returns the sum of all elements present in it. The return value may be an integer or a float. Unlike other array functions, this function does not ignore non-numeric elements and instead, they are converted to numbers before being summed.

For example, let's say that you have an array of dates from a POST form and want to calculate their sum. Normally, you would create a foreach loop that goes through each date in the array and sums them up. However, you can do this much easier with a built-in native function.

In the code below, we remove the foreach loop and the working sum variable, replacing them with a call to the array_sum() function. This simple modification will solve our problem and provide the same result.

oXygen is the leading XML Editor and Developer Studio with support for XML Schema, DTD, Relax NG, XPath, XSLT, and more. Try it free for 30 days.

Andreas Behr - CTO of DesertCoderz
You are a developer and looking for Shopware projects?
Apply Now!

array_sum example

// Count for each provider, if enabled         $config = json_decode($this->Request()->getParam('config', '{}'), true);
        $counts = [];
        foreach ($providers as $provider) {
            if ($config[$provider->getName()]) {
                $counts[$provider->getName()] = (int) $provider->getCount($context);
            } else {
                $counts[$provider->getName()] = 0;
            }
        }
        $counts['all'] = array_sum($counts);

        $counts = $this->get('events')->filter(
            'Shopware_Controllers_Performance_filterCounts',
            $counts
        );

        $this->View()->assign([
            'success' => true,
            'data' => [
                'counts' => $counts,
            ],
        ]);
/** * @return array<string> */
    public function getConnections(): array
    {
        return $this->data['connections'];
    }

    public function getQueryCount(): int
    {
        return array_sum(array_map('count', $this->data['queries']));
    }

    /** * @return array<string, array<int, SanitizedQueryInfo>> */
    public function getQueries(): array
    {
        return $this->data['queries'];
    }

    public function getTime(): float
    {
public function getScripts(string $hook): array
    {
        return $this->data[$hook] ?? [];
    }

    public function getTook(): float
    {
        $data = $this->data instanceof Data ? $this->data->getIterator() : $this->data;

        $took = 0.0;
        foreach ($data as $scripts) {
            $took += array_sum(array_column($scripts, 'took'));
        }

        return $took;
    }

    public function getScriptCount(): int
    {
        $count = 0;
        foreach ($this->data as $scripts) {
            $count += is_countable($scripts) ? \count($scripts) : 0;
        }

        
$total_items = $wp_query->found_posts;
        } else {
            $post_counts = (array) wp_count_posts( $post_type, 'readable' );

            if ( isset( $_REQUEST['post_status'] ) && in_array( $_REQUEST['post_status'], $avail_post_stati, true ) ) {
                $total_items = $post_counts[ $_REQUEST['post_status'] ];
            } elseif ( isset( $_REQUEST['show_sticky'] ) && $_REQUEST['show_sticky'] ) {
                $total_items = $this->sticky_posts_count;
            } elseif ( isset( $_GET['author'] ) && get_current_user_id() === (int) $_GET['author'] ) {
                $total_items = $this->user_posts_count;
            } else {
                $total_items = array_sum( $post_counts );

                // Subtract post types that are not included in the admin all list.                 foreach ( get_post_stati( array( 'show_in_admin_all_list' => false ) ) as $state ) {
                    $total_items -= $post_counts[ $state ];
                }
            }
        }

        $this->is_trash = isset( $_REQUEST['post_status'] ) && 'trash' === $_REQUEST['post_status'];

        $this->set_pagination_args(
            


        return array_merge(...array_values($this->logs));
    }

    public function countErrors(Request $request = null): int
    {
        if ($request) {
            return $this->errorCount[spl_object_id($request)] ?? 0;
        }

        return array_sum($this->errorCount);
    }

    public function clear(): void
    {
        $this->logs = [];
        $this->errorCount = [];
    }

    private function format(string $level, string $message, array $context, bool $prefixDate = true): string
    {
        if (str_contains($message, '{')) {
            

        usort($data, static function D$a, $b) {
            return $a['key'] <=> $b['key'];
        });

        $values = [];
        for ($i = 1; $i <= 4; ++$i) {
            $affected = array_filter($data, static function D$value) use ($i) {
                return $i <= ($value['key'] / 2);
            });

            $count = array_sum(array_column($affected, 'doc_count'));
            if ($count === 0) {
                continue;
            }

            $values[] = new ValueListItem($i, (string) $count, (int) $activeAverage === $i);
        }

        usort($values, static function DValueListItem $a, ValueListItem $b) {
            return $b->getId() <=> $a->getId();
        });

        
$this->filterLogsEntries($type_name);

      // Count the number of entries of this type.       $type_count = 0;
      foreach ($types as $type) {
        if ($type['type'] == $type_name) {
          $type_count += $type['count'];
        }
      }

      $count = $this->getTypeCount($types);
      $this->assertEquals($type_count, array_sum($count), 'Count matched');
    }

    // Set the filter to match each of the two filter-type attributes and     // confirm the correct number of entries are displayed.     foreach ($types as $type) {
      $this->filterLogsEntries($type['type'], $type['severity']);

      $count = $this->getTypeCount($types);
      $this->assertEquals($type['count'], array_sum($count), 'Count matched');
    }

    
<?php     }

    echo '<div id="plugin-information-scrollable">';
    echo "<div id='{$_tab}-title' class='{$_with_banner}'><div class='vignette'></div><h2>{$api->name}</h2></div>";
    echo "<div id='{$_tab}-tabs' class='{$_with_banner}'>\n";

    foreach ( (array) $api->sections as $section_name => $content ) {
        if ( 'reviews' === $section_name && ( empty( $api->ratings ) || 0 === array_sum( (array) $api->ratings ) ) ) {
            continue;
        }

        if ( isset( $plugins_section_titles[ $section_name ] ) ) {
            $title = $plugins_section_titles[ $section_name ];
        } else {
            $title = ucwords( str_replace( '_', ' ', $section_name ) );
        }

        $class       = ( $section_name === $section ) ? ' class="current"' : '';
        $href        = add_query_arg(
            

    public function getConnections()
    {
        return $this->data['connections'];
    }

    /** * @return int */
    public function getQueryCount()
    {
        return array_sum(array_map('count', $this->data['queries']));
    }

    /** * @return array */
    public function getQueries()
    {
        return $this->data['queries'];
    }

    /** * @return int */

        if ( ! isset( $this->count_cache[ $count_key2 ] ) ) {
            $this->count_cache[ $count_key2 ] = count_chars( $string2 );
        }

        $chars1 = $this->count_cache[ $count_key1 ];
        $chars2 = $this->count_cache[ $count_key2 ];

        $difference_key = md5( implode( ',', $chars1 ) . ':' . implode( ',', $chars2 ) );
        if ( ! isset( $this->difference_cache[ $difference_key ] ) ) {
            // L1-norm of difference vector.             $this->difference_cache[ $difference_key ] = array_sum( array_map( array( $this, 'difference' ), $chars1, $chars2 ) );
        }

        $difference = $this->difference_cache[ $difference_key ];

        // $string1 has zero length? Odd. Give huge penalty by not dividing.         if ( ! $string1 ) {
            return $difference;
        }

        // Return distance per character (of string1).         return $difference / strlen( $string1 );
    }

    protected function get_views() {
        $current_status = isset( $_REQUEST['filter-status'] ) ? sanitize_text_field( $_REQUEST['filter-status'] ) : '';
        $statuses       = _wp_privacy_statuses();
        $views          = array();
        $counts         = $this->get_request_counts();
        $total_requests = absint( array_sum( (array) $counts ) );

        // Normalized admin URL.         $admin_url = $this->get_admin_url();

        $status_label = sprintf(
            /* translators: %s: Number of requests. */
            _nx(
                'All <span class="count">(%s)</span>',
                'All <span class="count">(%s)</span>',
                $total_requests,
                'requests'
            ),

    public function countContent($shopId)
    {
        $this->registerShop($shopId);

        $counts = [
            Shopware()->Db()->fetchOne('SELECT COUNT(id) FROM `s_cms_support`'),
            Shopware()->Db()->fetchOne('SELECT COUNT(id) FROM `s_cms_static` WHERE link=\'\''),
        ];

        return array_sum($counts);
    }

    /** * Count Static routes * * @param int $shopId * * @return int */
    public function countStatic($shopId)
    {
        
if (empty($options)) {
      throw new \Exception('Options should be set before assigning a PoHeader.');
    }
    $overwrite_options = $options['overwrite_options'];

    // Check for langcode.     $langcode = $this->langcode;
    if (empty($langcode)) {
      throw new \Exception('Langcode should be set before assigning a PoHeader.');
    }

    if (array_sum($overwrite_options) || empty($locale_plurals[$langcode]['plurals'])) {
      // Get and store the plural formula if available.       $plural = $header->getPluralForms();
      if (isset($plural) && $p = $header->parsePluralForms($plural)) {
        [$nplurals, $formula] = $p;
        \Drupal::service('locale.plural.formula')->setPluralFormula($langcode, $nplurals, $formula);
      }
    }
  }

  /** * {@inheritdoc} */
$console->comment('Generate attribute sets: ' . $numberOfItems);
        $console->progressStart($numberOfItems);

        for ($i = 0; $i < $numberOfItems; ++$i) {
            $this->generateCustomFieldSet($options, $context);

            $console->progressAdvance(1);
        }
        $console->progressFinish();

        $relations = $options['relations'];
        $sum = (int) array_sum($relations);
        if ($sum <= 0) {
            return;
        }

        $console->comment('Set attributes for entities: ' . $sum);
        $console->progressStart($sum);
        foreach ($relations as $relation => $count) {
            if (!$count || $count < 1) {
                continue;
            }

            
            // the general purpose field. We can use this to differentiate             // between a compressed document, and a ZIP file             $zip_compressed_on_the_fly = ((0x08 & $general_purpose_flag) === 0x08);

            if (!$zip_compressed_on_the_fly) {
                // Don't attempt to decode a compressed zip file                 return $gz_data;
            }

            // Determine the first byte of data, based on the above ZIP header             // offsets:             $first_file_start = array_sum(unpack('v2', substr($gz_data, 26, 4)));
            $decompressed     = @gzinflate(substr($gz_data, 30 + $first_file_start));
            if ($decompressed !== false) {
                return $decompressed;
            }

            return false;
        }

        // Finally fall back to straight gzinflate         $decompressed = @gzinflate($gz_data);
        if ($decompressed !== false) {
            
Home | Imprint | This part of the site doesn't use cookies.