बूटस्ट्रैप का उपयोग करके तीन कॉलम के साथ एनजी-रिपीट डेटा को कैसे विभाजित किया जाए


122

मैं अपने कोड के साथ एनजी-रिपीट का उपयोग कर रहा हूं मेरे पास एन-रिपीट पर आधारित टेक्स्ट बॉक्स की संख्या 'एन' है। मैं टेक्स्टबॉक्स को तीन कॉलम के साथ संरेखित करना चाहता हूं।

यह मेरा कोड है

<div class="control-group" ng-repeat="oneExt in configAddr.ext">
    {{$index+1}}. 
    <input type="text" name="macAdr{{$index+1}}" 
           id="macAddress" ng-model="oneExt.newValue" value=""/>
</div>

1
तो मान लें कि आपके पास नौ (9) हैं, आप एक पंक्ति में या स्तंभ में 1,2,3 चाहते हैं?
गेब्रियल पेट्रीओली

जवाबों:


254

नियंत्रक में डेटा को बदलने के लिए सबसे विश्वसनीय और तकनीकी रूप से सही दृष्टिकोण है। यहाँ एक सरल कार्य और उपयोग है।

function chunk(arr, size) {
  var newArr = [];
  for (var i=0; i<arr.length; i+=size) {
    newArr.push(arr.slice(i, i+size));
  }
  return newArr;
}

$scope.chunkedData = chunk(myData, 3);

तब आपका विचार इस तरह दिखाई देगा:

<div class="row" ng-repeat="rows in chunkedData">
  <div class="span4" ng-repeat="item in rows">{{item}}</div>
</div>

यदि आपके पास कोई इनपुट है ng-repeat, तो आप संभवतः सरणियों को अनचेक / रिजेक्ट करना चाहेंगे क्योंकि डेटा संशोधित या सबमिट किया गया है। यहाँ है कि यह एक में कैसे दिखेगा$watch , ताकि डेटा हमेशा मूल, मर्ज किए गए प्रारूप में उपलब्ध हो:

$scope.$watch('chunkedData', function(val) {
  $scope.data = [].concat.apply([], val);
}, true); // deep watch

कई लोग इसे फ़िल्टर के साथ दृश्य में पूरा करना पसंद करते हैं। यह संभव है, लेकिन केवल प्रदर्शन उद्देश्यों के लिए उपयोग किया जाना चाहिए! यदि आप इस फ़िल्टर किए गए दृश्य के भीतर इनपुट जोड़ते हैं, तो यह समस्याओं का कारण बन सकता है उन जिन्हें हल किया सकता है, लेकिन सुंदर या विश्वसनीय नहीं हैं ।

इस फ़िल्टर के साथ समस्या यह है कि यह हर बार नए नेस्टेड सरणियों को लौटाता है। कोणीय फिल्टर से रिटर्न वैल्यू देख रहा है। पहली बार फ़िल्टर चलता है, कोणीय मूल्य जानता है, फिर यह सुनिश्चित करने के लिए इसे फिर से चलाता है कि यह बदल रहा है। यदि दोनों मान समान हैं, तो चक्र समाप्त हो गया है। यदि नहीं, तो फ़िल्टर बार-बार आग लगाएगा जब तक कि वे समान नहीं होते हैं, या कोणीय को पता चलता है कि एक अनन्त डाइजेस्ट लूप घटित हो रहा है और नीचे बन्द हो जाता है। क्योंकि नए नेस्टेड एरेज़ / ऑब्जेक्ट्स को पहले से कोणीय द्वारा ट्रैक नहीं किया गया था, यह हमेशा रिटर्न मान को पिछले से अलग देखता है। इन "अस्थिर" फिल्टर को ठीक करने के लिए, आपको एक मॉड्यूल में फिल्टर को लपेटना होगा और स्क्रिप्ट को या उसके साथ संकलित करना होगाmemoize फ़ंक्शन । lodashएक memoizeफ़ंक्शन होता है और लॉस्ट के नवीनतम संस्करण में एक chunkफ़ंक्शन भी शामिल होता है, इसलिए हम इस फ़िल्टर को बहुत ही सरलता से उपयोग कर सकते हैंnpmbrowserifywebpack

याद रखें: केवल प्रदर्शन! नियंत्रक में फ़िल्टर करें यदि आप इनपुट का उपयोग कर रहे हैं!

दर्ज करें:

npm install lodash-node

फ़िल्टर बनाएं:

var chunk = require('lodash-node/modern/array/chunk');
var memoize = require('lodash-node/modern/function/memoize');

angular.module('myModule', [])
.filter('chunk', function() {
  return memoize(chunk);
});

और यहाँ इस फिल्टर के साथ एक नमूना है:

<div ng-repeat="row in ['a','b','c','d','e','f'] | chunk:3">
  <div class="column" ng-repeat="item in row">
    {{($parent.$index*row.length)+$index+1}}. {{item}}
  </div>
</div>

आइटम लंबवत ऑर्डर करें

1  4
2  5
3  6

क्षैतिज (बाएं से दाएं) के बजाय ऊर्ध्वाधर कॉलम (नीचे से ऊपर की ओर सूची) के संबंध में, सटीक कार्यान्वयन वांछित शब्दार्थ पर निर्भर करता है। असमान रूप से विभाजित होने वाली सूचियों को विभिन्न तरीकों से वितरित किया जा सकता है। यहाँ एक तरीका है:

<div ng-repeat="row in columns">
  <div class="column" ng-repeat="item in row">
    {{item}}
  </div>
</div>
var data = ['a','b','c','d','e','f','g'];
$scope.columns = columnize(data, 3);
function columnize(input, cols) {
  var arr = [];
  for(i = 0; i < input.length; i++) {
    var colIdx = i % cols;
    arr[colIdx] = arr[colIdx] || [];
    arr[colIdx].push(input[i]);
  }
  return arr;
}

हालाँकि, स्तंभों को प्राप्त करने का सबसे सीधा और सरल तरीका है सीएसएस कॉलम का उपयोग करना :

.columns {
  columns: 3;
}
<div class="columns">
  <div ng-repeat="item in ['a','b','c','d','e','f','g']">
    {{item}}
  </div>
</div>

आपकी सहायता के लिए धन्यवाद। लेकिन कोणीय में यूआई-चार्ट के साथ हिंडोला का उपयोग चार्ट बीटी हिंडोला ठीक काम नहीं कर सकता है। मेरा कोड है <हिंडोला अंतराल = "myInterval"> <स्लाइड एनजी-रिपीट = "मील के पत्थर में मील का पत्थर | विभाजन: 4" सक्रिय = "स्लाइड. एक्टिव"> <div class = "col-md-3": ng-repeat = " मील के पत्थर में "" <div style = "text-align: center;"> <div ui-chart = "data" चार्ट-विकल्प = "चार्ट विकल्प"> </ div> </ div> </ div> </ स्लाइड > </ हिंडोला> और मैं मील का पत्थर JSON डेटा के रूप में अपने दायरे चर शुरू में।
कुपु

1
@ m59 अभी यह कार्य पहली पंक्ति a b cदूसरी पंक्ति में डेटा प्रदर्शित करता है d e f। क्या मैं a b पहले कॉलम c dको दूसरे कॉलम में और e fतीसरे कॉलम में प्रदर्शित कर सकता हूं ? धन्यवाद

1
@ Ifch0o1 यदि आप सही होते तो [].concat.call([], val)। आपको विचार करना चाहिए कि क्या applyकरता है। valसरणियों की एक सरणी है, और हम इसके अंदर उन सरणियों में से प्रत्येक को तर्क के रूप में पारित करना चाहते हैं concat। मुझे लगता है कि आप उस संदर्भ पर ध्यान केंद्रित कर रहे हैं [], जो यहाँ की बात नहीं है। हम जो चाहते हैं [].concat(val[1], val[2], val[3], etc), वह है , इसलिए हमें जरूरत हैapply([], val)
m59

1
@ बहादुर ने उत्तर को अधिक स्पष्ट होने के लिए अद्यतन किया। देखें कि क्या होता है यदि आप एक फिल्टर बनाते हैं जो सिर्फ []बनाम [[]]और रिटर्न देता है [{}]। नेस्टेड ऐरे / ऑब्जेक्ट एंगुलर को हर पर एक अलग परिणाम दिखाई देता है filter, और परिणाम को वही (स्थिर) रखने के लिए दोहराता रहता है।
m59

1
आप वास्तव में टिप्पणियों को स्पैम कर रहे हैं :) अपने लिए प्रयास करें। var x = [1,2,3]; var y = [1,2,3]; console.log(x === y);डीप चेकिंग का अर्थ स्ट्रिंग्स की तुलना करना और उनकी तुलना करना है, जो जोखिम भरा है क्योंकि कोई वस्तु कठोर नहीं हो सकती है, या प्रत्येक संपत्ति की व्यक्तिगत रूप से पुनरावृत्ति कर सकती है। मुझे लगता है कि कोणीय फिल्टर के लिए लागू कर सकता है , लेकिन मुझे यकीन है कि वहाँ अच्छा कारण वे नहीं था। संभवतः क्योंकि वे मुख्य रूप से डेटा-सेट के सरल संशोधन के लिए फ़िल्टर करते हैं, न कि संरचना में परिवर्तन के साथ एक पूर्ण ओवरहाल।
15:59 पर m59

64

यह समाधान बहुत सरल है:

JSON:

[{id:"1",name:"testA"},{id:"2",name:"test B"},{id:"3",name:"test C"},{id:"4",name:"test D"},{id:"5",name:"test E"}]

HTML:

<div ng-controller="MyCtrl">
  <table>
    <tr ng-repeat="item in items" ng-switch on="$index % 3">
      <td ng-switch-when="0">
        {{items[$index].id}} {{items[$index].name}}
      </td>
      <td ng-switch-when="0">
        <span ng-show="items[$index+1]">
          {{items[$index+1].id}} {{items[$index+1].name}}
        </span>
      </td>
      <td ng-switch-when="0">
        <span ng-show="items[$index+2]">    
          {{items[$index+2].id}} {{items[$index+2].name}}
        </span>
      </td>
    </tr>
  </table>
</div>

FIDDLE में डेमो

यहाँ छवि विवरण दर्ज करें


3
सबसे बढ़िया उत्तर! और देशी निर्देशों के साथ क्या करना चाहिए! Congratz!
रेनन फ्रेंका

1
यह समाधान काम करता है, लेकिन जहाँ तक सर्वोत्तम प्रथाओं का पालन होता है, आपको संभवतः अपने मार्कअप में लेआउट को परिभाषित करने के लिए तालिकाओं का उपयोग नहीं करना चाहिए :)
डेव कूपर

2
जैसा कि @DaveCooper उल्लेख करता है, यहां टेबल के बिना एक वैकल्पिक लेआउट है: plnkr.co/edit/81oj8mHaNyfQpCmRBWO4?p=preview । सारणीबद्ध डेटा के लिए तालिकाओं पर विचार करें, लेकिन अन्यथा, यह मोबाइल उपकरणों और चर स्क्रीन आकारों के लिए एक बेहतर लेआउट है।
ज़िमोटिक

1
यह अब तक का सबसे अच्छा समाधान है। एक नए ढांचे का उपयोग करते समय सभी quirks खोजने में समय लगता है लेकिन एनजी-स्विच एक गॉडसेंड है
Zoran

यदि आप टेबल के बजाय डिव के लिए जा रहे हैं, तो आप ng-switch-when="0"सभी 3 आइटमों के बजाय एक बार बाहरी div पर रख सकते हैं ।
हंस वाउटर्स

19

एक साफ, अनुकूलनीय समाधान जिसमें डेटा हेरफेर की आवश्यकता नहीं होती है :

HTML:

<div class="control-group" class="label"
    ng-repeat="oneExt in configAddr.ext"
    ng-class="{'new-row': startNewRow($index, columnBreak) }">
    {{$index+1}}. 
    <input type="text" name="macAdr{{$index+1}}" 
       id="macAddress{{$index}}" ng-model="oneExt.newValue" />
</div>

सीएसएस:

.label {
    float: left;
    text-align: left;
}
.new-row {
    clear: left;
}

जावास्क्रिप्ट:

$scope.columnBreak = 3; //Max number of colunms
$scope.startNewRow = function (index, count) {
    return ((index) % count) === 0;
};

यह डेटा को पंक्तियों और स्तंभों में गतिशील रूप से रेंडर करने के लिए एक सरल उपाय है जिसमें आप जिस डेटा को प्रदर्शित करने का प्रयास कर रहे हैं उसके सरणी में हेरफेर करने की कोई आवश्यकता नहीं है। इसके अलावा अगर आप ब्राउज़र विंडो को आकार देने की कोशिश करते हैं तो आप ग्रिड को गतिशील रूप से स्क्रीन / डिव के आकार में देख सकते हैं।

(मैंने अपनी आईडी में एक {{$ इंडेक्स}} प्रत्यय भी जोड़ा है क्योंकि एनजी-रिपीट एक ही आईडी के साथ कई तत्वों को बनाने की कोशिश करेगा यदि आप नहीं करते हैं।)

एक समान कार्य उदाहरण


1
मेरा मानना ​​है कि ओपी को ट्विटर बूटस्ट्रैप पंक्तियों / स्तंभों के लिए मार्कअप चाहिए था, लेकिन यह किसी के लिए मददगार हो सकता है। हालांकि, आपको अपने उत्तर में कोड और स्पष्टीकरण डालने की आवश्यकता है। लिंक केवल उत्तर हटा दिए जाएंगे।
m59

@ m59 अपडेट किया गया उत्तर। सुझाव के लिए धन्यवाद
कमलु निंबस

1
बिग +1 के लिए डेटा हेरफेर की आवश्यकता नहीं है । इसने एनजी-रिपीट का उपयोग करके 2 कॉलम में डेटा को अलग करने की मेरी जरूरतों के लिए एकदम सही काम किया, ताकि मेरा बूटस्ट्रैप मॉडल इतना लंबा न हो! मुझे आश्चर्य हुआ कि इसे लागू करना कितना सरल था! <span ng-repeat="z in waiverModalLinks" ng-class="{'new-row':startNewRow($index, columnBreak)}" class="{{z.id}}"><a href="{{z.link}}{{z.title}}">{{z.title}}</a></span>वह `मोडल-बॉडी’ के अंदर है।
क्रिस्टीन

15

m59 का जवाब बहुत अच्छा है। एक चीज जो मुझे पसंद नहीं है, वह यह है कि यह उपयोग करता हैdiv किसी तालिका के लिए संभावित रूप से डेटा हो सकता है के लिए एस ।

तो m59 के फिल्टर (ऊपर कहीं जवाब) के साथ संयोजन के रूप में, यहां बताया गया है कि इसे एक तालिका में कैसे प्रदर्शित किया जाए।

<table>
    <tr class="" ng-repeat="rows in foos | chunk:2">
        <td ng-repeat="item in rows">{{item}}</td>
    </tr>
</table>

7

निम्नलिखित एक अधिक सरल तरीका है:

<table>
    <tr ng-repeat="item in lists" ng-hide="$index%2!==0">
        <td>
            <label>{{ lists[$index].name}}</label>
        </td>
        <td ng-hide="!lists[$index+1]">
            <label>{{ lists[$index+1].name}}</label>
        </td>
    </tr>
</table>

क्यूमुल्बो निंबस का जवाब मेरे लिए उपयोगी है लेकिन मैं चाहता हूं कि यह ग्रिड एक डिव से लिपटा हो जो स्क्रॉलबार को दिखा सकता है जब सूची बहुत लंबी हो।

इसे प्राप्त करने के लिए मैंने जोड़ा style="height:200px; overflow:auto" तालिका के चारों ओर एक div में , जिसके कारण यह एकल स्तंभ के रूप में प्रदर्शित होता है।

अब एक की सरणी लंबाई के लिए काम करता है।


जब सरणी में केवल 1 आइटम होता है तो यह पहली पंक्ति को प्रदर्शित नहीं करता है। इस परिवर्तन को ठीक करने के लिए ng-hide="$index%2!==0"
अनुज पांडे

4

मेरे पास एक फ़ंक्शन है और इसे एक सेवा में संग्रहीत किया है, इसलिए मैं इसे अपने ऐप पर उपयोग कर सकता हूं:

सर्विस:

app.service('SplitArrayService', function () {
return {
    SplitArray: function (array, columns) {
        if (array.length <= columns) {
            return [array];
        };

        var rowsNum = Math.ceil(array.length / columns);

        var rowsArray = new Array(rowsNum);

        for (var i = 0; i < rowsNum; i++) {
            var columnsArray = new Array(columns);
            for (j = 0; j < columns; j++) {
                var index = i * columns + j;

                if (index < array.length) {
                    columnsArray[j] = array[index];
                } else {
                    break;
                }
            }
            rowsArray[i] = columnsArray;
        }
        return rowsArray;
    }
}

});

नियंत्रक:

$scope.rows   = SplitArrayService.SplitArray($scope.images, 3); //im splitting an array of images into 3 columns

मार्कअप:

 <div class="col-sm-12" ng-repeat="row in imageRows">
     <div class="col-sm-4" ng-repeat="image in row">
         <img class="img-responsive" ng-src="{{image.src}}">
     </div>
 </div>

जबकि यह अच्छा है, यह अन्य फिल्टर जैसे कि ऑर्डरबाय या फिल्टर का उपयोग करते समय मदद नहीं करता है।
रॉबी स्मिथ

2

मेरा दृष्टिकोण चीजों का मिश्रण था।

मेरा उद्देश्य स्क्रीन आकार के लिए एक ग्रिड को अपनाना था। मुझे 3 कॉलम चाहिए lg, 2 कॉलम के लिए smऔर md, और 1 कॉलम के लिएxs

सबसे पहले, मैंने कोणीय $windowसेवा का उपयोग करते हुए निम्नलिखित कार्यक्षेत्र बनाया :

$scope.findColNumberPerRow = function() {
    var nCols;
    var width = $window.innerWidth;

    if (width < 768) {
        // xs
        nCols = 1;
    }
    else if(width >= 768 && width < 1200) {
         // sm and md
         nCols = 2
    } else if (width >= 1200) {
        // lg
        nCols = 3;
    }
    return nCols;
};

फिर, मैंने @Cumulo Nimbus द्वारा प्रस्तावित वर्ग का उपयोग किया:

.new-row {
    clear: left;
}

युक्त div में ng-repeat, मैं जोड़ा resizableनिर्देश के रूप में में बताया गया है, इस पेज है, ताकि हर बार खिड़की, आकार दिया कोणीय है $windowसेवा नए मूल्यों के साथ अद्यतन किया जाता है।

अंततः, मेरे द्वारा दोहराए गए div में:

ng-repeat="user in users" ng-class="{'new-row': ($index % findColNumberPerRow() === 0) }"

कृपया, मुझे इस दृष्टिकोण में कोई दोष बताएं।

आशा है कि यह मददगार हो सकता है।


2

बूटस्ट्रैप द्वारा अनुशंसित "क्लीयरफिक्स" सीएसएस के साथ एक सरल चाल:

<div class="row">
      <div ng-repeat-start="value in values" class="col-md-4">
        {{value}}
      </div>
      <div ng-repeat-end ng-if="$index % 3 == 0" class="clearfix"></div>
</div>

कई फायदे: कुशल, तेज, बूस्ट्रेप सिफारिशों का उपयोग करते हुए, संभव $ पचने वाले मुद्दों से बचना, और कोणीय मॉडल में फेरबदल नहीं करना।


1

यह उदाहरण एक नेस्टेड रिपीटर का उत्पादन करता है जहां बाहरी डेटा में एक आंतरिक सरणी शामिल होती है जिसे मैं दो कॉलम में सूचीबद्ध करना चाहता था। यह अवधारणा तीन या अधिक स्तंभों के लिए सही होगी।

आंतरिक कॉलम में मैं "पंक्ति" को दोहराता हूं जब तक कि सीमा पूरी नहीं हो जाती। सीमा वांछित वस्तुओं के कॉलम की संख्या को इस मामले में दो से विभाजित करके निर्धारित की जाती है। विभाजन विधि नियंत्रक पर बैठती है और एक पैरामीटर के रूप में वर्तमान सरणी लंबाई पारित की जाती है। फिर जावास्क्रिप्ट स्लाइस (0, array.length / columnCount) फ़ंक्शन ने रिपीटर की सीमा को लागू किया।

दूसरे कॉलम रिपीटर को तब स्लाइस और बार-बार स्लाइस (array.length / columnCount, array.length) के रूप में लाया जाता है, जो कॉलम दो में एरे के दूसरे हाफ को प्रोड्यूस करता है।

<div class="row" ng-repeat="GroupAccess in UsersController.SelectedUser.Access" ng-class="{even: $even, odd: $odd}">
    <div class="col-md-12 col-xs-12" style=" padding-left:15px;">
        <label style="margin-bottom:2px;"><input type="checkbox" ng-model="GroupAccess.isset" />{{GroupAccess.groupname}}</label>
    </div>
    <div class="row" style=" padding-left:15px;">
        <div class="col-md-1 col-xs-0"></div>
        <div class="col-md-3 col-xs-2">
            <div style="line-height:11px; margin-left:2px; margin-bottom:2px;" ng-repeat="Feature in GroupAccess.features.slice(0, state.DivideBy2(GroupAccess.features.length))">
                <span class="GrpFeature">{{Feature.featurename}}</span>
            </div>
        </div>
        <div class="col-md-3 col-xs-2">
            <div style="line-height:11px; margin-left:2px; margin-bottom:2px;" ng-repeat="Feature in GroupAccess.features.slice( state.DivideBy2(GroupAccess.features.length), GroupAccess.features.length )">
                <span class="GrpFeature">{{Feature.featurename}}</span>
            </div>
        </div>
        <div class="col-md-5 col-xs-8">
        </div>
    </div>
</div>


// called to format two columns
state.DivideBy2 = function(nValue) {
    return Math.ceil(nValue /2);
};

आशा है कि यह अभी तक दूसरे तरीके से समाधान को देखने में मदद करता है। (पुनश्च यह मेरी यहाँ पहली पोस्ट है! :-))


1

मैं बिना डूबे ठीक करता हूं

<div class="col col-33 left" ng-repeat="photo in photos">
   Content here...
</div>

और सीएसएस

.left {
  float: left;
}

1

यहाँ यह करने का एक आसान तरीका है। यह अधिक मैनुअल है और गन्दा मार्कअप के साथ समाप्त होता है। मैं इसकी अनुशंसा नहीं करता, लेकिन ऐसी परिस्थितियां हैं जहां यह उपयोगी हो सकता है।

यहाँ एक फिडेल लिंक है http://jsfiddle.net/m0nk3y/9wcbpydq/

HTML:

<div ng-controller="myController">
    <div class="row">
        <div class="col-sm-4">
            <div class="well">
                <div ng-repeat="person in people = data | limitTo:Math.ceil(data.length/3)">
                {{ person.name }}
                </div>
            </div>
        </div>
        <div class="col-sm-4">
            <div class="well">
                <div ng-repeat="person in people = data | limitTo:Math.ceil(data.length/3):Math.ceil(data.length/3)">
                {{ person.name }}
                </div>
            </div>
        </div>
        <div class="col-sm-4">
            <div class="well">
                <div ng-repeat="person in people = data | limitTo:Math.ceil(data.length/3):Math.ceil(data.length/3)*2">
                {{ person.name }}
                </div>
            </div>
        </div>
    </div>
</div>

जे एस:

var app = angular.module('myApp', []);

app.controller('myController', function($scope) {

    $scope.Math = Math;
    $scope.data = [
        {"name":"Person A"},
        ...
    ];
});

इस सेटअप के लिए हमें मार्कअप पर कुछ गणित का उपयोग करना होगा: /, इसलिए आपको इस लाइन को जोड़कर गणित को इंजेक्ट करना होगा: $scope.Math = Math;


1

इन सभी के जवाब बड़े पैमाने पर इंजीनियर लगते हैं।

अब तक की सबसे सरल विधि इनपुट divs को col-md-4 कॉलम बूटस्ट्रैप में स्थापित करना होगा, फिर बूटस्ट्रैप बूटस्ट्रैप के 12 कॉलम प्रकृति के कारण स्वचालित रूप से इसे 3 कॉलम में प्रारूपित करेगा:

<div class="col-md-12">
    <div class="control-group" ng-repeat="oneExt in configAddr.ext">
        <div class="col-md-4">
            <input type="text" name="macAdr{{$index}}"
                   id="macAddress" ng-model="oneExt.newValue" value="" />
        </div>
    </div>
</div>

1
<div class="row">
  <div class="col-md-4" ng-repeat="remainder in [0,1,2]">
    <ul>
      <li ng-repeat="item in items" ng-if="$index % 3 == remainder">{{item}}</li>
    </ul>
  </div>
</div>

0

M59 के बहुत अच्छे उत्तर के आधार पर। मैंने पाया कि यदि वे बदलते हैं तो मॉडल इनपुट धुंधले हो जाएंगे, इसलिए आप एक बार में केवल एक ही चरित्र को बदल सकते हैं। यह किसी के लिए वस्तुओं की सूची के लिए एक नया है जो इसकी आवश्यकता है:

संपादित करें एक पृष्ठ पर कई फिल्टर को संभालने के लिए अपडेट किया गया

app.filter('partition', function() {
  var cache = {}; // holds old arrays for difference repeat scopes
  var filter = function(newArr, size, scope) {
    var i,
      oldLength = 0,
      newLength = 0,
      arr = [],
      id = scope.$id,
      currentArr = cache[id];
    if (!newArr) return;

    if (currentArr) {
      for (i = 0; i < currentArr.length; i++) {
        oldLength += currentArr[i].length;
      }
    }
    if (newArr.length == oldLength) {
      return currentArr; // so we keep the old object and prevent rebuild (it blurs inputs)
    } else {
      for (i = 0; i < newArr.length; i += size) {
        arr.push(newArr.slice(i, i + size));
      }
      cache[id] = arr;
      return arr;
    }
  };
  return filter;
}); 

और यह उपयोग होगा:

<div ng-repeat="row in items | partition:3:this">
  <span class="span4">
    {{ $index }}
  </span>
</div>

जहां तक ​​मैं बता सकता हूं, यह ज्यादातर समय काम करना चाहिए लेकिन यह कैशिंग लॉजिक पूरी तरह से विश्वसनीय नहीं लगता है और गुंजाइश से गुजरना अजीब है। मैं वास्तव में इनपुट की आवश्यकता होने पर नियंत्रक के भीतर फ़िल्टरिंग की सलाह देता हूं। यह वैसे भी तकनीकी रूप से सही दृष्टिकोण है।
2059 पर m59

0

मैं बूटस्ट्रैप और एंगुलरज में नया हूं, लेकिन यह एक समूह के रूप में 4 आइटम प्रति एरे बना सकता है, परिणाम लगभग 3 कॉलम होगा। यह ट्रिक बूटस्ट्रैप ब्रेक लाइन सिद्धांत का उपयोग करता है।

<div class="row">
 <div class="col-sm-4" data-ng-repeat="item in items">
  <div class="some-special-class">
   {{item.XX}}
  </div>
 </div>
</div>

0

लॉडश में एक चंक विधि निर्मित है जिसे अब मैं व्यक्तिगत रूप से उपयोग करता हूं: https://lodash.com/docs#chunk

इसके आधार पर, नियंत्रक कोड निम्नलिखित की तरह लग सकता है:

$scope.groupedUsers = _.chunk( $scope.users, 3 )

कोड देखें:

<div class="row" ng-repeat="rows in groupedUsers">
  <div class="span4" ng-repeat="item in rows">{{item}}</div>
</div>

0

एक और तरीका width:33.33%; float:leftइस तरह एक आवरण div के लिए सेट है:

<div ng-repeat="right in rights" style="width: 33.33%;float: left;">
    <span style="width:60px;display:inline-block;text-align:right">{{$index}}</span>
    <input type="number" style="width:50px;display:inline-block" ">
</div>

0

मैंने खुद को एक समान मामले में पाया, प्रत्येक 3 कॉलम के प्रदर्शन समूहों को उत्पन्न करना चाहता था। हालाँकि, हालांकि मैं बूटस्ट्रैप का उपयोग कर रहा था, लेकिन मैं इन समूहों को अलग-अलग माता-पिता में विभाजित करने की कोशिश कर रहा था। मैं कुछ उदारतापूर्वक उपयोगी बनाना चाहता था।

मैंने ng-repeatनीचे के रूप में 2 के साथ संपर्क किया :

<div ng-repeat="items in quotes" ng-if="!($index % 3)">
  <div ng-repeat="quote in quotes" ng-if="$index <= $parent.$index + 2 && $index >= $parent.$index">
                ... some content ...
  </div>
</div>

इससे स्तंभों की एक अलग संख्या में बदलना बहुत आसान हो जाता है, और कई अभिभावकों के विभाग में अलग हो जाते हैं।


0

बस अगर कोई एक कोणीय 7 (और उच्चतर संस्करण) चाहता है तो यहां एक उदाहरण है जिसे मैंने अपने अनुप्रयोगों में उपयोग किया है:

HTML:

                   <div class="container-fluid">
                    <div class="row" *ngFor="let reports of chunkData; index as i">
                        <div *ngFor="let report of reports" class="col-4 col-sm-4"
                            style="border-style:solid;background-color: antiquewhite">{{report}}</div>
                    </div>
                </div>

.TS फ़ाइल

export class ConfirmationPageComponent implements OnInit {
  chunkData = [];
  reportsArray = ["item 1", "item 2", "item 3", "item 4", "item 5", "item 6"];
  
  constructor() {}

  ngOnInit() {
    this.chunkData = this.chunk(this.reportsArray, 3);
  }

  chunk(arr, size) {
    var newArr = [];
    for (var i = 0; i < arr.length; i += size) {
      newArr.push(arr.slice(i, i + size));
    }
    return newArr;
  }
}

यह डेटाबेस से आपके आइटमरेटिंग आइटम्स के आधार पर गतिशील रूप से नए कॉलम / रो बनाने के लिए एक भयानक समाधान है। धन्यवाद!


-1

यह मूल प्रश्न का उत्तर देता है कि एक कॉलम में 1,2,3 कैसे प्राप्त करें। - 13:47 पर कुप्पू फ़रवरी 8 '14 द्वारा पूछा गया

कोणीयज कोड:

function GetStaffForFloor(floor) {
    var promiseGet = Directory_Service.getAllStaff(floor);
    promiseGet.then(function (pl) {
        $scope.staffList = chunk(pl.data, 3); //pl.data; //
    },
    function (errorOD) {
        $log.error('Errored while getting staff list.', errorOD);
    });
}
function chunk(array, columns) {
    var numberOfRows = Math.ceil(array.length / columns);

    //puts 1, 2, 3 into column
    var newRow = []; //array is row-based.
    for (var i = 0; i < array.length; i++) {
        var columnData = new Array(columns);
        if (i == numberOfRows) break;
        for (j = 0; j < columns; j++)
        {
            columnData[j] = array[i + numberOfRows * j];
        }
        newRow.push(columnData); 
    }
    return newRow;

    ////this works but 1, 2, 3 is in row
    //var newRow = [];
    //for (var i = 0; i < array.length; i += columns) {
    //    newRow.push(array.slice(i, i + columns)); //push effectively does the pivot. array is row-based.
    //}
    //return newRow;
};

कोड देखें (नोट: बूटस्ट्रैप 3 का उपयोग करके):

<div class="staffContainer">
    <div class="row" ng-repeat="staff in staffList">
        <div class="col-md-4" ng-repeat="item in staff">{{item.FullName.length > 0 ? item.FullName + ": Rm " + item.RoomNumber : ""}}</div>
    </div>
</div>

-1

यह कोड तीन स्तंभों के साथ lg, और md मोड, sm मोड में दो कॉलम और एकल कॉलम xx मोड के साथ तत्वों को संरेखित करने में मदद करेगा।

<div class="row">
<div ng-repeat="oneExt in configAddr.ext">
    <div class="col-xs-12 col-sm-6 col-md-4 col-lg-4">
        {$index+1}}. 
        <input type="text" name="macAdr{{$index+1}}" 
       id="macAddress" ng-model="oneExt.newValue" value=""/>
    </div>
</div>

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.