AngularJS एनजी-रिपीट में बार-बार तत्वों की गणना

Question

नीचे दी गई स्क्रिप्ट एक दुकान की कार्ट का उपयोग करके प्रदर्शित करती है ng-repeat। सरणी में प्रत्येक तत्व के लिए, यह आइटम का नाम, उसकी राशि और उप-योग ( product.price * product.quantity) दिखाता है ।

दोहराया तत्वों की कुल कीमत की गणना करने का सबसे सरल तरीका क्या है?

<table>

    <tr>
        <th>Product</th>
        <th>Quantity</th>
        <th>Price</th>
    </tr>

    <tr ng-repeat="product in cart.products">
        <td>{{product.name}}</td>
        <td>{{product.quantity}}</td>
        <td>{{product.price * product.quantity}} €</td>
    </tr>

    <tr>
        <td></td>
        <td>Total :</td>
        <td></td> <!-- Here is the total value of my cart -->
    </tr>

</table>

Comments

angular.forEach ($ स्कोप ।art.products, फंक्शन (filterObj, filterKey) {$ स्कोप ।.talal + = filterObj.product.price * filterObj.product.quantity;});

— ग्वारी

इसे भी देखें: stackoverflow.com/a/25667437/59087

— डेव जार्विस

stackoverflow.com/questions/22731145/…

— राजामोहन अंगूचामी

आप tfoot- टैग का उपयोग क्यों नहीं करते?

— पास्कल

Answer 1

टेम्पलेट में

<td>Total: {{ getTotal() }}</td>

नियंत्रक में

$scope.getTotal = function(){
    var total = 0;
    for(var i = 0; i < $scope.cart.products.length; i++){
        var product = $scope.cart.products[i];
        total += (product.price * product.quantity);
    }
    return total;
}

Comments

इसका एक नकारात्मक पहलू यह है कि यह संग्रह पर दो बार प्रसारित होता है। यह छोटे संग्रह के लिए ठीक है, लेकिन क्या होगा यदि संग्रह बड़ा नहीं है? ऐसा लगता है कि एनजी-रिपीट में किसी दिए गए ऑब्जेक्ट फ़ील्ड पर रनिंग सम होने का एक तरीका होना चाहिए।

— icfantv

@ पास्केलम मेरे जवाब की जांच करें ( stackoverflow.com/questions/22731145/… ) मुझे लगता है कि जो आप फिल्टर के बारे में पूछ रहे हैं, उसके लिए काम करने वाला

— राजामोहन अंगुचामी

जब मैं उस प्रश्न पर उतरा था, तो मैं क्या देख रहा था, इसके लिए धन्यवाद @RajaShilpa!

— पास्केलम सेप

इस समाधान के साथ मुख्य मुद्दा यह है कि कुल को हर पाचन से पुनर्गणना किया जाएगा, क्योंकि यह एक फ़ंक्शन कॉल है।

— मार्क डर्डिन

@icfantv कैसे दो बार संग्रह पर चलना है?

— क्रिश्चियन रामिरेज़

Answer 2

यह फ़िल्टर और सामान्य सूची दोनों पर भी काम कर रहा है। सूची से सभी मूल्यों के योग के लिए एक नया फ़िल्टर बनाने के लिए पहली चीज़, और कुल मात्रा के योग के लिए समाधान भी दिया गया है। डिटेल्स कोड में इसे फिडलर लिंक चेक करें ।

angular.module("sampleApp", [])
        .filter('sumOfValue', function () {
        return function (data, key) {        
            if (angular.isUndefined(data) || angular.isUndefined(key))
                return 0;        
            var sum = 0;        
            angular.forEach(data,function(value){
                sum = sum + parseInt(value[key], 10);
            });        
            return sum;
        }
    }).filter('totalSumPriceQty', function () {
        return function (data, key1, key2) {        
            if (angular.isUndefined(data) || angular.isUndefined(key1)  || angular.isUndefined(key2)) 
                return 0;        
            var sum = 0;
            angular.forEach(data,function(value){
                sum = sum + (parseInt(value[key1], 10) * parseInt(value[key2], 10));
            });
            return sum;
        }
    }).controller("sampleController", function ($scope) {
        $scope.items = [
          {"id": 1,"details": "test11","quantity": 2,"price": 100}, 
          {"id": 2,"details": "test12","quantity": 5,"price": 120}, 
          {"id": 3,"details": "test3","quantity": 6,"price": 170}, 
          {"id": 4,"details": "test4","quantity": 8,"price": 70}
        ];
    });


<div ng-app="sampleApp">
  <div ng-controller="sampleController">
    <div class="col-md-12 col-lg-12 col-sm-12 col-xsml-12">
      <label>Search</label>
      <input type="text" class="form-control" ng-model="searchFilter" />
    </div>
    <div class="col-md-12 col-lg-12 col-sm-12 col-xsml-12">
      <div class="col-md-2 col-lg-2 col-sm-2 col-xsml-2">
        <h4>Id</h4>

      </div>
      <div class="col-md-4 col-lg-4 col-sm-4 col-xsml-4">
        <h4>Details</h4>

      </div>
      <div class="col-md-2 col-lg-2 col-sm-2 col-xsml-2 text-right">
        <h4>Quantity</h4>

      </div>
      <div class="col-md-2 col-lg-2 col-sm-2 col-xsml-2 text-right">
        <h4>Price</h4>

      </div>
      <div class="col-md-2 col-lg-2 col-sm-2 col-xsml-2 text-right">
        <h4>Total</h4>

      </div>
      <div ng-repeat="item in resultValue=(items | filter:{'details':searchFilter})">
        <div class="col-md-2 col-lg-2 col-sm-2 col-xsml-2">{{item.id}}</div>
        <div class="col-md-4 col-lg-4 col-sm-4 col-xsml-4">{{item.details}}</div>
        <div class="col-md-2 col-lg-2 col-sm-2 col-xsml-2 text-right">{{item.quantity}}</div>
        <div class="col-md-2 col-lg-2 col-sm-2 col-xsml-2 text-right">{{item.price}}</div>
        <div class="col-md-2 col-lg-2 col-sm-2 col-xsml-2 text-right">{{item.quantity * item.price}}</div>
      </div>
      <div colspan='3' class="col-md-8 col-lg-8 col-sm-8 col-xsml-8 text-right">
        <h4>{{resultValue | sumOfValue:'quantity'}}</h4>

      </div>
      <div class="col-md-2 col-lg-2 col-sm-2 col-xsml-2 text-right">
        <h4>{{resultValue | sumOfValue:'price'}}</h4>

      </div>
      <div class="col-md-2 col-lg-2 col-sm-2 col-xsml-2 text-right">
        <h4>{{resultValue | totalSumPriceQty:'quantity':'price'}}</h4>

      </div>
    </div>
  </div>
</div>

इस फिडल लिंक की जाँच करें

Comments

अरे मैं 'undefined'का उपयोग करते समय मिल रहा है resultValue, लेकिन अगर मैं इसका उपयोग itemsकरता है ठीक काम करता है, किसी भी विचार .. ??

— सलाल असलम

जहाँ आप पहले निम्न कोड "resultValue = (आइटम | फ़िल्टर: {'विवरण': searchFilter})" की जांच करते हैं, क्योंकि सभी फ़िल्टर मान उस चर "resultValue" में संग्रहीत करते हैं। मुझे लगता है कि आप उस {} या () के लिए गलत हैं, एक बार फिर से सत्यापित करें।

— राजामोहन अंगुचमी

अगर मैं इसका उपयोग itemsकरता हूं तो यह फिल्टर के साथ काम नहीं करेगा, मदद करें!

— सलाल असलम

मेरा कोड इस तरह है ng-repeat="campaign in filteredCampaigns=(campaigns | filter:{'name':q})"और{{ filteredCampaigns | campaignTotal: 'totalCommission' | number: 2 }}

— सलाल असलम

हां, क्योंकि आइटम अभी तक फ़िल्टर नहीं किए गए हैं, फ़िल्टर होने के बाद परिणाम किसी अन्य मॉडल को संग्रहीत करने के लिए होना चाहिए और केवल उस मॉडल का उपयोग करना चाहिए। मेरे नमूने में मैंने "resultValue" मॉडल का उपयोग किया।

— राजामोहन अंगूचामी

Answer 3

इसका उत्तर बहुत पहले मिल गया था, लेकिन प्रस्तुत नहीं किया गया अलग दृष्टिकोण पोस्ट करना चाहता था ...

ng-initअपने कुल का मिलान करने के लिए उपयोग करें । इस तरह, आपको HTML में पुनरावृति और नियंत्रक में पुनरावृति करने की आवश्यकता नहीं है। इस परिदृश्य में, मुझे लगता है कि यह एक क्लीनर / सरल उपाय है। (यदि टैलींग लॉजिक अधिक जटिल था, तो मैं निश्चित रूप से लॉजिक को कंट्रोलर या सर्विस में ले जाने की सलाह दूंगा।)

    <tr>
        <th>Product</th>
        <th>Quantity</th>
        <th>Price</th>
    </tr>

    <tr ng-repeat="product in cart.products">
        <td>{{product.name}}</td>
        <td>{{product.quantity}}</td>
        <td ng-init="itemTotal = product.price * product.quantity; controller.Total = controller.Total + itemTotal">{{itemTotal}} €</td>
    </tr>

    <tr>
        <td></td>
        <td>Total :</td>
        <td>{{ controller.Total }}</td> // Here is the total value of my cart
    </tr>

बेशक, अपने नियंत्रक में, अपने Totalक्षेत्र को परिभाषित / प्रारंभ करें :

// random controller snippet
function yourController($scope..., blah) {
    var vm = this;
    vm.Total = 0;
}

Comments

यह निश्चित रूप से सबसे कोणीय तरीका है। सरल, पठनीय और घोषणात्मक। इसलिए, यह जिस तर्क का प्रतिनिधित्व करता है वह वहीं रहता है जहां यह होता है।

— डैनियल Leiszen

यह विधि सेल प्रस्तुति में गणना को छुपाती है, जिसे यहां समझना आसान है, लेकिन जटिल तालिकाओं के साथ बहुत गड़बड़ हो जाता है।

— मार्क डर्डिन

इसके साथ दूसरा मुद्दा यह है कि यह दो तरह से बाध्यकारी नहीं है।

— पॉल कार्लटन

Answer 4

आप ng-repeatअनुसरण के अंदर कुल गणना कर सकते हैं :

<tbody ng-init="total = 0">
  <tr ng-repeat="product in products">
    <td>{{ product.name }}</td>
    <td>{{ product.quantity }}</td>
    <td ng-init="$parent.total = $parent.total + (product.price * product.quantity)">${{ product.price * product.quantity }}</td>
  </tr>
  <tr>
    <td>Total</td>
    <td></td>
    <td>${{ total }}</td>
  </tr>
</tbody>

यहां देखें रिजल्ट: http://plnkr.co/edit/Gb8XiCf2RWiozFI3xWzp?p=preview

मामले में स्वत: अद्यतन परिणाम: http://plnkr.co/edit/QSxYbgjDjkuSH2s5JBPf?p=preview (साभार - विजार्डन)

Comments

सूची फ़िल्टर होने पर यह अभ्यस्त कार्य - tbodyकेवल एक बार प्रारंभ होता है, लेकिन trहर बार सूची को फ़िल्टर किया जाता है, जिसके परिणामस्वरूप गलत योग होता है

— Zbynek

क्या आप plnkr या jsfiddle पर एक उदाहरण बना सकते हैं?

— ह्यू गुयेन

हम्म, हाँ, यह फिल्टर में काम नहीं कर रहा है क्योंकि यहाँ फ़िल्टर सिर्फ देखने / छुपाने के लिए है, अपडेट नहीं$scope

— Huy Nguyen

@HuyNguyen, मैंने आपका उपरोक्त कोड संपादित कर दिया है। कृपया यहाँ देखें: plnkr.co/edit/QSxYbgjDjkuSH2s5JBPf?p=preview । यहां मैं चाहता हूं कि यदि उपयोगकर्ता मात्रा में परिवर्तन करता है तो 4 वें कॉलम (मूल्य * मात्रा) को स्वचालित रूप से अपडेट किया जाना चाहिए। क्या आप इस पर एक नज़र डाल सकते हैं। धन्यवाद

— Vikasdeep सिंह

Answer 5

यह मेरा समाधान है

मीठा और सरल कस्टम फिल्टर:

(लेकिन केवल मानों के सरल योग से संबंधित है, उत्पाद के योग नहीं, मैंने sumProductफ़िल्टर बनाया है और इसे इस पोस्ट में संपादित किया है)।

angular.module('myApp', [])

    .filter('total', function () {
        return function (input, property) {
            var i = input instanceof Array ? input.length : 0;
// if property is not defined, returns length of array
// if array has zero length or if it is not an array, return zero
            if (typeof property === 'undefined' || i === 0) {
                return i;
// test if property is number so it can be counted
            } else if (isNaN(input[0][property])) {
                throw 'filter total can count only numeric values';
// finaly, do the counting and return total
            } else {
                var total = 0;
                while (i--)
                    total += input[i][property];
                return total;
            }
        };
    })

जेएस फिडल

संपादित करें: योग

यह sumProductफ़िल्टर है, यह किसी भी तर्क को स्वीकार करता है। एक तर्क के रूप में यह इनपुट डेटा से संपत्ति के नाम को स्वीकार करता है, और यह नेस्टेड संपत्ति (डॉट द्वारा चिह्नित नेस्टिंग:) को संभाल सकता है property.nested;

• शून्य तर्क पास करना इनपुट डेटा की लंबाई देता है।
• सिर्फ एक तर्क पारित करने से उस गुणों के मूल्यों का सरल योग प्राप्त होता है।
• अधिक तर्क पारित करना पारित किए गए गुणों के मूल्यों के उत्पादों का योग देता है (गुणों का स्केलर योग)।

यहाँ जेएस फिडेल और कोड है

angular.module('myApp', [])
    .filter('sumProduct', function() {
        return function (input) {
            var i = input instanceof Array ? input.length : 0;
            var a = arguments.length;
            if (a === 1 || i === 0)
                return i;

            var keys = [];
            while (a-- > 1) {
                var key = arguments[a].split('.');
                var property = getNestedPropertyByKey(input[0], key);
                if (isNaN(property))
                    throw 'filter sumProduct can count only numeric values';
                keys.push(key);
            }

            var total = 0;
            while (i--) {
                var product = 1;
                for (var k = 0; k < keys.length; k++)
                    product *= getNestedPropertyByKey(input[i], keys[k]);
                total += product;
            }
            return total;

            function getNestedPropertyByKey(data, key) {
                for (var j = 0; j < key.length; j++)
                    data = data[key[j]];
                return data;
            }
        }
    })

जेएस फिडल

Answer 6

सरल उपाय

यहाँ एक सरल उपाय है। लूप के लिए कोई अतिरिक्त आवश्यकता नहीं है।

HTML हिस्सा

         <table ng-init="ResetTotalAmt()">
                <tr>
                    <th>Product</th>
                    <th>Quantity</th>
                    <th>Price</th>
                </tr>

                <tr ng-repeat="product in cart.products">
                    <td ng-init="CalculateSum(product)">{{product.name}}</td>
                    <td>{{product.quantity}}</td>
                    <td>{{product.price * product.quantity}} €</td>
                </tr>

                <tr>
                    <td></td>
                    <td>Total :</td>
                    <td>{{cart.TotalAmt}}</td> // Here is the total value of my cart
                </tr>

           </table>

लिपि भाग

 $scope.cart.TotalAmt = 0;
 $scope.CalculateSum= function (product) {
   $scope.cart.TotalAmt += (product.price * product.quantity);
 }
//It is enough to Write code $scope.cart.TotalAmt =0; in the function where the cart.products get allocated value. 
$scope.ResetTotalAmt = function (product) {
   $scope.cart.TotalAmt =0;
 }

Answer 7

इसे हल करने का एक और तरीका, इस विशेष गणना को हल करने के लिए वैक्लेव के उत्तर से विस्तार - यानी प्रत्येक पंक्ति पर एक गणना।

    .filter('total', function () {
        return function (input, property) {
            var i = input instanceof Array ? input.length : 0;
            if (typeof property === 'undefined' || i === 0) {
                return i;
            } else if (typeof property === 'function') {
                var total = 0; 
                while (i--)
                    total += property(input[i]);
                return total;
            } else if (isNaN(input[0][property])) {
                throw 'filter total can count only numeric values';
            } else {
                var total = 0;
                while (i--)
                    total += input[i][property];
                return total;
            }
        };
    })

गणना के साथ ऐसा करने के लिए, बस अपने कार्यक्षेत्र में एक गणना फ़ंक्शन जोड़ें, उदा

$scope.calcItemTotal = function(v) { return v.price*v.quantity; };

आप {{ datas|total:calcItemTotal|currency }}अपने HTML कोड में उपयोग करेंगे । यह हर डाइजेस्ट के लिए न कहे जाने का लाभ है, क्योंकि यह फिल्टर का उपयोग करता है, और सरल या जटिल योग के लिए इस्तेमाल किया जा सकता है।

JSFiddle

Answer 8

यह सभी मानों को एकत्र करने के लिए एनजी-रिपीट और एनजी-इनिट के साथ ऐसा करने का एक सरल तरीका है और एक आइटम के साथ मॉडल का विस्तार करें।

<table>
<tr ng-repeat="item in items" ng-init="setTotals(item)">
                    <td>{{item.name}}</td>
                    <td>{{item.quantity}}</td>
                    <td>{{item.unitCost | number:2}}</td>
                    <td>{{item.total | number:2}}</td>
</tr>
<tr class="bg-warning">
                    <td>Totals</td>
                    <td>{{invoiceCount}}</td>
                    <td></td>                    
                    <td>{{invoiceTotal | number:2}}</td>
                </tr>
</table>

NgInit निर्देश प्रत्येक आइटम के लिए सेट कुल फ़ंक्शन को कॉल करता है। नियंत्रक में सेटटोटल्स फ़ंक्शन प्रत्येक आइटम की कुल गणना करता है। यह सभी आइटमों के लिए मात्रा और कुल योग करने के लिए इनवॉइसकाउंट और इनवॉइसटाल स्कोप चर का उपयोग करता है।

$scope.setTotals = function(item){
        if (item){
            item.total = item.quantity * item.unitCost;
            $scope.invoiceCount += item.quantity;
            $scope.invoiceTotal += item.total;
        }
    }

अधिक जानकारी के लिए और इस लिंक पर डेमो देखें:

http://www.ozkary.com/2015/06/angularjs-calculate-totals-using.html

Comments

StackOverlow पर हतोत्साहित हो सकने वाले आपके ब्लॉग पोस्ट के लिंक इसके अलावा, जब मैं पृष्ठ को देखता हूं तो मुझे आपके पृष्ठ के मध्य में 502 खराब गेटवे त्रुटि मिलती है। प्रश्न का उत्तर यहीं दीजिए, कहीं और की कड़ी नहीं।

— रिक ग्लोस

Answer 9

मैं सुरुचिपूर्ण समाधान पसंद करता हूं

टेम्पलेट में

<td>Total: {{ totalSum }}</td>

नियंत्रक में

$scope.totalSum = Object.keys(cart.products).map(function(k){
    return +cart.products[k].price;
}).reduce(function(a,b){ return a + b },0);

यदि आप ES2015 (उर्फ ES6) का उपयोग कर रहे हैं

$scope.totalSum = Object.keys(cart.products)
  .map(k => +cart.products[k].price)
  .reduce((a, b) => a + b);

Answer 10

आप एक कस्टम कोणीय फ़िल्टर का उपयोग कर सकते हैं जो योग ऑब्जेक्ट ऑब्जेक्ट सरणी और प्रत्येक ऑब्जेक्ट में कुंजी को योग करने के लिए ले जाता है। फ़िल्टर फिर राशि लौटा सकता है:

.filter('sumColumn', function(){
        return function(dataSet, columnToSum){
            let sum = 0;

            for(let i = 0; i < dataSet.length; i++){
                sum += parseFloat(dataSet[i][columnToSum]) || 0;
            }

            return sum;
        };
    })

फिर अपनी तालिका में उस कॉलम का योग करें जिसका आप उपयोग कर सकते हैं:

<th>{{ dataSet | sumColumn: 'keyInObjectToSum' }}</th>

Answer 11

आप कोणीय js की सेवाओं का उपयोग करने की कोशिश कर सकते हैं, इसने मेरे लिए काम किया है .. नीचे दिए गए कोड स्निपेट को देते हुए

नियंत्रक कोड:

$scope.total = 0;
var aCart = new CartService();

$scope.addItemToCart = function (product) {
    aCart.addCartTotal(product.Price);
};

$scope.showCart = function () {    
    $scope.total = aCart.getCartTotal();
};

सेवा कोड:

app.service("CartService", function () {

    Total = [];
    Total.length = 0;

    return function () {

        this.addCartTotal = function (inTotal) {
            Total.push( inTotal);
        }

        this.getCartTotal = function () {
            var sum = 0;
            for (var i = 0; i < Total.length; i++) {
                sum += parseInt(Total[i], 10); 
            }
            return sum;
        }
    };
});

Answer 12

यहाँ इस समस्या का हल है:

<td>Total: {{ calculateTotal() }}</td>

लिपि

$scope.calculateVAT = function () {
    return $scope.cart.products.reduce((accumulator, currentValue) => accumulator + (currentValue.price * currentValue.quantity), 0);
};

कम उत्पाद सरणी में प्रत्येक उत्पाद के लिए निष्पादित करेगा। Accumulator कुल संचित राशि है, currentValue सरणी का वर्तमान तत्व है और अंतिम में 0 मूल्य है

Answer 13

मैंने राजाशिल्पी के उत्तर पर थोड़ा विस्तार किया। आप सिंटैक्स का उपयोग कर सकते हैं जैसे:

{{object | sumOfTwoValues:'quantity':'products.productWeight'}}

ताकि आप किसी ऑब्जेक्ट के चाइल्ड ऑब्जेक्ट को एक्सेस कर सकें। यहाँ फिल्टर के लिए कोड है:

.filter('sumOfTwoValues', function () {
    return function (data, key1, key2) {
        if (typeof (data) === 'undefined' || typeof (key1) === 'undefined' || typeof (key2) === 'undefined') {
            return 0;
        }
        var keyObjects1 = key1.split('.');
        var keyObjects2 = key2.split('.');
        var sum = 0;
        for (i = 0; i < data.length; i++) {
            var value1 = data[i];
            var value2 = data[i];
            for (j = 0; j < keyObjects1.length; j++) {
                value1 = value1[keyObjects1[j]];
            }
            for (k = 0; k < keyObjects2.length; k++) {
                value2 = value2[keyObjects2[k]];
            }
            sum = sum + (value1 * value2);
        }
        return sum;
    }
});

Answer 14

Vaclav का उत्तर लेना और इसे अधिक कोणीय बनाना जैसे:

angular.module('myApp').filter('total', ['$parse', function ($parse) {
    return function (input, property) {
        var i = input instanceof Array ? input.length : 0,
            p = $parse(property);

        if (typeof property === 'undefined' || i === 0) {
            return i;
        } else if (isNaN(p(input[0]))) {
            throw 'filter total can count only numeric values';
        } else {
            var total = 0;
            while (i--)
                total += p(input[i]);
            return total;
        }
    };
}]);

यह आपको नेस्टेड और सरणी डेटा तक पहुँचने का लाभ देता है:

{{data | total:'values[0].value'}}

Answer 15

Html में

<b class="text-primary">Total Amount: ${{ data.allTicketsTotalPrice() }}</b>

जावास्क्रिप्ट में

  app.controller('myController', function ($http) {
            var vm = this;          
            vm.allTicketsTotalPrice = function () {
                var totalPrice = 0;
                angular.forEach(vm.ticketTotalPrice, function (value, key) {
                    totalPrice += parseFloat(value);
                });
                return totalPrice.toFixed(2);
            };
        });

Answer 16

ह्यू गुयेन का जवाब लगभग वहीं है। इसे काम करने के लिए, जोड़ें:

ng-repeat="_ in [ products ]"

... एनजी-इनिट के साथ लाइन में। सूची में हमेशा एक ही आइटम होता है, इसलिए कोणीय ठीक एक बार ब्लॉक को दोहराएगा।

फ़िल्टरिंग का उपयोग करके Zybnek का डेमो जोड़कर काम किया जा सकता है:

ng-repeat="_ in [ [ products, search ] ]"

Http://plnkr.co/edit/dLSntiy8EyahZ0upDpgy?p=preview देखें ।

Answer 17

**Angular 6: Grand Total**       
 **<h2 align="center">Usage Details Of {{profile$.firstName}}</h2>
        <table align ="center">
          <tr>
            <th>Call Usage</th>
            <th>Data Usage</th>
            <th>SMS Usage</th>
            <th>Total Bill</th>
          </tr>
          <tr>
          <tr *ngFor="let user of bills$">
            <td>{{ user.callUsage}}</td>
            <td>{{ user.dataUsage }}</td>
            <td>{{ user.smsUsage }}</td>
       <td>{{user.callUsage *2 + user.dataUsage *1 + user.smsUsage *1}}</td>
          </tr>


          <tr>
            <th> </th>
            <th>Grand Total</th>
            <th></th>
            <td>{{total( bills$)}}</td>
          </tr>
        </table>**


    **Controller:**
        total(bills) {
            var total = 0;
            bills.forEach(element => {
total = total + (element.callUsage * 2 + element.dataUsage * 1 + element.smsUsage * 1);
            });
            return total;
        }

Comments

समीक्षा से: ढेर अतिप्रवाह में आपका स्वागत है! कृपया स्रोत कोड के साथ जवाब न दें। आपका समाधान कैसे काम करता है, इसके बारे में अच्छा विवरण देने का प्रयास करें। देखें: मैं एक अच्छा उत्तर कैसे लिखूं? । धन्यवाद

— sɐunıɔ ןɐ qɐp

Answer 18

यह मेरा समाधान है

<div ng-controller="MainCtrl as mc">
  <ul>
      <li ng-repeat="n in [1,2,3,4]" ng-init="mc.sum = ($first ? 0 : mc.sum) + n">{{n}}</li>
      <li>sum : {{mc.sum}}</li>
  </ul>
</div>

इसके लिए आपको नाम जोड़ने की आवश्यकता है क्योंकि Controller as SomeNameहम चर को कैश कर सकते हैं (क्या वास्तव में इसकी आवश्यकता है? मैं $ माता-पिता का उपयोग करने से परिचित नहीं हूं, इसलिए मुझे पता नहीं है)

फिर प्रत्येक दोहराने के लिए, जोड़ें ng-init"SomeName.SumVariable = ($first ? 0 : SomeName.SumVariable) + repeatValue"

$first इसकी जाँच के लिए यह पहले शून्य पर रीसेट हो जाता है, अन्यथा यह कुल मूल्य को जारी रखेगा

http://jsfiddle.net/thainayu/harcv74f/

Answer 19

यहां सभी उत्तरों को पढ़ने के बाद - समूहीकृत जानकारी को कैसे संक्षेप में प्रस्तुत किया जाए, मैंने इसे सभी को छोड़ने का फैसला किया और सिर्फ SQL जावास्क्रिप्ट स्क्रिप्ट में से एक को लोड किया। मैं alasql का उपयोग कर रहा हूँ, हाँ, यह लोड समय पर कुछ सेकंड लेता है, लेकिन कोडिंग और डीबगिंग में अनगिनत समय बचाता है, अब समूह और योग करने के लिए () मैं अभी उपयोग करता हूं

$scope.bySchool = alasql('SELECT School, SUM(Cost) AS Cost from ? GROUP BY School',[restResults]);

मुझे पता है कि यह कोणीय / js पर एक शेख़ी की तरह लगता है, लेकिन वास्तव में SQL ने इसे 30+ साल पहले हल किया था और हमें इसे एक ब्राउज़र में फिर से आविष्कार नहीं करना चाहिए।

Comments

यह बहुत ही भयानक है। बस वाह एसएमएच - मैं अन्य लोगों को वोट देने दूंगा। इस जवाब के साथ मेरा मुंह खुला है .....

— टॉम स्टिकेल