केवल जावास्क्रिप्ट में LINQ SelectMany () के बराबर कैसे करें

Question 1

दुर्भाग्य से, मेरे पास JQuery या अंडरस्कोर नहीं है, बस शुद्ध जावास्क्रिप्ट (IE9 संगत) है।

मैं LINQ कार्यक्षमता से SelectMany () के बराबर चाहता हूं।

// SelectMany flattens it to just a list of phone numbers.
IEnumerable<PhoneNumber> phoneNumbers = people.SelectMany(p => p.PhoneNumbers);

क्या इसे मै कर सकता हूँ?

संपादित करें:

जवाब के लिए धन्यवाद, मुझे यह काम मिल गया:

var petOwners = 
[
    {
        Name: "Higa, Sidney", Pets: ["Scruffy", "Sam"]
    },
    {
        Name: "Ashkenazi, Ronen", Pets: ["Walker", "Sugar"]
    },
    {
        Name: "Price, Vernette", Pets: ["Scratches", "Diesel"]
    },
];

function property(key){return function(x){return x[key];}}
function flatten(a,b){return a.concat(b);}

var allPets = petOwners.map(property("Pets")).reduce(flatten,[]);

console.log(petOwners[0].Pets[0]);
console.log(allPets.length); // 6

var allPets2 = petOwners.map(function(p){ return p.Pets; }).reduce(function(a, b){ return a.concat(b); },[]); // all in one line

console.log(allPets2.length); // 6

Question 2

एक सरल चयन के लिए आप ऐरे के कम फ़ंक्शन का उपयोग कर सकते हैं।
आओ हम कहते हैं कि आपके पास संख्याओं का सारणी है:

var arr = [[1,2],[3, 4]];
arr.reduce(function(a, b){ return a.concat(b); });
=>  [1,2,3,4]

var arr = [{ name: "name1", phoneNumbers : [5551111, 5552222]},{ name: "name2",phoneNumbers : [5553333] }];
arr.map(function(p){ return p.phoneNumbers; })
   .reduce(function(a, b){ return a.concat(b); })
=>  [5551111, 5552222, 5553333]

संपादित करें:
चूंकि es6 फ्लैटपाइप को ऐरे प्रोटोटाइप में जोड़ा गया है। SelectManyका पर्याय है flatMap।
विधि पहले मैपिंग फ़ंक्शन का उपयोग करके प्रत्येक तत्व को मैप करती है, फिर परिणाम को एक नए सरणी में समतल करती है। टाइपस्क्रिप्ट में इसका सरलीकृत हस्ताक्षर है:

function flatMap<A, B>(f: (value: A) => B[]): B[]

कार्य को प्राप्त करने के लिए हमें बस प्रत्येक तत्व को फोन करने के लिए फ्लैट-मैप करना होगा

arr.flatMap(a => a.phoneNumbers);

Question 3

एक सरल विकल्प के रूप में Array.prototype.flatMap () या Array.prototype.flat ()

const data = [
{id: 1, name: 'Dummy Data1', details: [{id: 1, name: 'Dummy Data1 Details'}, {id: 1, name: 'Dummy Data1 Details2'}]},
{id: 1, name: 'Dummy Data2', details: [{id: 2, name: 'Dummy Data2 Details'}, {id: 1, name: 'Dummy Data2 Details2'}]},
{id: 1, name: 'Dummy Data3', details: [{id: 3, name: 'Dummy Data3 Details'}, {id: 1, name: 'Dummy Data3 Details2'}]},
]

const result = data.flatMap(a => a.details); // or data.map(a => a.details).flat(1);
console.log(result)

स्निपेट का विस्तार करें

Question 4

थोड़ी देर बाद उन लोगों के लिए, जावास्क्रिप्ट को समझना लेकिन फिर भी टाइपस्क्रिप्ट में एक सरल टाइप की गई चयन विधि:

function selectMany<TIn, TOut>(input: TIn[], selectListFn: (t: TIn) => TOut[]): TOut[] {
  return input.reduce((out, inx) => {
    out.push(...selectListFn(inx));
    return out;
  }, new Array<TOut>());
}

Question 5

सरणी को समतल करने के लिए कॉन्कैट विधि का उपयोग करने में सगी सही है। लेकिन इस उदाहरण के समान कुछ पाने के लिए, आपको चयनित भाग https://msdn.microsoft.com/library/bb534336(v=vs.100).aspx के लिए एक मानचित्र की आवश्यकता होगी

/* arr is something like this from the example PetOwner[] petOwners = 
                    { new PetOwner { Name="Higa, Sidney", 
                          Pets = new List<string>{ "Scruffy", "Sam" } },
                      new PetOwner { Name="Ashkenazi, Ronen", 
                          Pets = new List<string>{ "Walker", "Sugar" } },
                      new PetOwner { Name="Price, Vernette", 
                          Pets = new List<string>{ "Scratches", "Diesel" } } }; */

function property(key){return function(x){return x[key];}}
function flatten(a,b){return a.concat(b);}

arr.map(property("pets")).reduce(flatten,[])

Question 6

// you can save this function in a common js file of your project
function selectMany(f){ 
    return function (acc,b) {
        return acc.concat(f(b))
    }
}

var ex1 = [{items:[1,2]},{items:[4,"asda"]}];
var ex2 = [[1,2,3],[4,5]]
var ex3 = []
var ex4 = [{nodes:["1","v"]}]

चलो शुरू करते हैं

ex1.reduce(selectMany(x=>x.items),[])

=> [1, 2, 4, "असदा"]

ex2.reduce(selectMany(x=>x),[])

=> [1, 2, 3, 4, 5]

ex3.reduce(selectMany(x=> "this will not be called" ),[])

=> []

ex4.reduce(selectMany(x=> x.nodes ),[])

=> ["1", "वी"]

नोट: कम फ़ंक्शन में गहन मान के रूप में मान्य सरणी (गैर नल) का उपयोग करें

Question 7

यह कोशिश करो (es6 के साथ):

 Array.prototype.SelectMany = function (keyGetter) {
 return this.map(x=>keyGetter(x)).reduce((a, b) => a.concat(b)); 
 }

उदाहरण सरणी:

 var juices=[
 {key:"apple",data:[1,2,3]},
 {key:"banana",data:[4,5,6]},
 {key:"orange",data:[7,8,9]}
 ]

का उपयोग कर:

juices.SelectMany(x=>x.data)

Question 8

मैं यह करूँगा (परहेज .concat ()):

function SelectMany(array) {
    var flatten = function(arr, e) {
        if (e && e.length)
            return e.reduce(flatten, arr);
        else 
            arr.push(e);
        return arr;
    };

    return array.reduce(flatten, []);
}

var nestedArray = [1,2,[3,4,[5,6,7],8],9,10];
console.log(SelectMany(nestedArray)) //[1,2,3,4,5,6,7,8,9,10]

यदि आप .reduce () का उपयोग नहीं करना चाहते हैं:

function SelectMany(array, arr = []) {
    for (let item of array) {
        if (item && item.length)
            arr = SelectMany(item, arr);
        else
            arr.push(item);
    }
    return arr;
}

यदि आप .forEach () का उपयोग करना चाहते हैं:

function SelectMany(array, arr = []) {
    array.forEach(e => {
        if (e && e.length)
            arr = SelectMany(e, arr);
        else
            arr.push(e);
    });

    return arr;
}

Question 9

यहाँ आप टाइप, किसी एक्सटेंशन पर प्रयोग करने योग्य टाइपस्क्रिप्ट में joel-harkes के उत्तर को फिर से लिखे गए संस्करण पर जाते हैं। तो आप सचमुच इसे पसंद कर सकते हैं somearray.selectMany(c=>c.someprop)। ट्रांस-ढेर, यह जावास्क्रिप्ट है।

declare global {
    interface Array<T> {
        selectMany<TIn, TOut>(selectListFn: (t: TIn) => TOut[]): TOut[];
    }
}

Array.prototype.selectMany = function <TIn, TOut>( selectListFn: (t: TIn) => TOut[]): TOut[] {
    return this.reduce((out, inx) => {
        out.push(...selectListFn(inx));
        return out;
    }, new Array<TOut>());
}


export { };

Question 10

आप उस manipulaपैकेज को आज़मा सकते हैं जो सभी C # LINQ विधियों को लागू करता है और इसके सिंटैक्स को संरक्षित करता है:

Manipula.from(petOwners).selectMany(x=>x.Pets).toArray()

https://github.com/litichevskiydv/manipula

https://www.npmjs.com/package/manipula