Pregunta Utilice reducir para acortar la matriz


Use reducir para encontrar la cantidad de veces que un elemento está en una matriz. La matriz podría tener matrices dentro recursivamente.

var foo = [
  1,
  [2, 3, 4], 
  4, [5,6,7], 4
];

bar(foo, 4) Volvería 3.


5
2017-12-30 19:09


origen


Respuestas:


Prueba este usando Array.prototype.reduce.

var foo = [1, [2, 3, 4], 4, [5, 6, 7], 4];

function f(arr, item) {
  return arr.reduce(function (s, i) {
    if (Array.isArray(i)) return s+f(i, item);
    return s+(i==item?1:0);
  }, 0);
}

console.log(f(foo, 4))

La función f Es una función recursiva. Recorrimos todos los elementos y los reducimos a un número. La función se activaría también en todos los arreglos internos, y para los elementos que no forman parte del mismo, simplemente verificamos que sean iguales al elemento deseado.


4
2017-12-30 19:24



Puedes contar todos los artículos con una sola llamada con Array.prototype.forEach()

los forEach() método ejecuta una función proporcionada una vez por elemento de conjunto.

Y una comprobación de si el elemento es una matriz, entonces la función se llama de nuevo con la matriz como parámetro.

var foo = ["a", ["b", "c", "d"], "a"],
    object = {};

function count(a, o) {
    a.forEach(function (b) {
        if (Array.isArray(b)) {
            count(b, o);
        } else {
            o[b] = (o[b] || 0) + 1;
        }
    })
}

count(foo, object);
document.write('<pre>' + JSON.stringify(object, 0, 4) + '</pre>');


4
2017-12-30 19:18



Así que si quieres una recursión (y funcionará en cualquier navegador):

var foo = [
    "a",
    ["b", "c", "d"], 
    "a"
];

function bar(arr, item) {
    var count = 0;
    if (arr.length == 0) {
        return 0;
    }

    for (var i = 0, l = arr.length; i < l; i++) {
        var v = arr[i];
        if (typeof v === "string") {
            if (v === item) {
                count++;
            }
        } else {
            count = count + bar(v, item);
        }
    }

    return count;
}

console.log(bar(foo, "a"));

2
2017-12-30 19:26



Aquí hay otro tipo funcional de interpretación que no requiere un estado externo, aunque sería más ineficiente.

var foo = [
  "a",
  ["b", "c", "d"],
  ["a", "b"],
  "a"
];

function flatten( arr ){
  return arr.reduce(function( ret, curr ){
    return ret.concat( Array.isArray( curr ) ? flatten( curr ) : [ curr ] );
  }, []);
}

function filterBy( arr, val ){
  return arr.filter(function( item ){
    return item === val;
  })
}

console.log( flatten( foo ) );
console.log( filterBy( flatten( foo ), 'a') );
<script src="http://codepen.io/synthet1c/pen/WrQapG.js"></script>


2
2017-12-30 19:39



Utilizando guion bajo puedes contar la cantidad de ocurrencia de cada elemento con este código:

_.countBy(_.flatten(array), _.identity)

Así que la función foo se puede implementar así:

function bar(foo, element){
    return _.countBy(_.flatten(foo), _.identity)[element];
}
var foo = ["a", ["b", "c", "d"], "a"]
console.log(bar(foo, "a"));

Aunque esta solución no es recursiva, merece la pena mencionarla.


1
2017-12-30 20:00