Problemas lógicos comuns em Javascript e suas soluções

Um, contar a ocorrência do valor igual a item no array arr

function count(arr, item) {
   var count = 0;
   arr.forEach(function(e){
     //e for each element in arr, if e is equal to item then count+1
     e == item ? count++ : 0;
   });
   return count;
 }
function count(arr, item) {
  return arr.filter(function(a){
    return (a==item);
  }).length
}
function count(arr, item) {
var res;
return (res = arr.toString().match(new RegExp("//"b"+item+"//b","g")))?res.length:0;
}
function count(arr, item) {
      var count = 0;
      arr.map(function(a) {
        if(a === item) {
          count++;
        }
      });
      return count;
    }

Segundo, calcular o quadrado ao quadrado de cada elemento do array arr. Não modificar diretamente o array arr, retornar um novo array como resultado

function square(arr) {
  return arr.map(function(item,index,array){
    return item*item;
  })
}
function square(arr) {
  //declara um novo array para armazenar os resultados
   var a = [];
   arr.forEach(function(e){
     //adicionar ao array a cada elemento ao quadrado, após adicionar ao array a
     a.push(e*e);
   });
   return a;
 }
function square(arr) {
//copia um array arr
  var newarr = arr.slice(0);
  for (var i=0;i<newarr.length;i++){
    newarr[i]= newarr[i]* newarr[i];
  }
  return newarr;
}
function square(arr) {
  return arr.map(function(item){
    return Math.pow(item, 2);
  })
}

Terceiro, usar os elementos do array arr como argumentos da chamada da função fn

function argsAsArray(fn, arr) {
 return fn.apply(this, arr);
 }
function argsAsArray(fn, arr) {
  return function(para1,para2){ 
    return para1.apply(this,para2);
  }(fn,arr);
}

Quarto, completar a função createModule, após a chamada, deve atender aos seguintes requisitos:

　　　　 1retorna um objeto

　　　　 2o valor do atributo greeting do objeto iguala str1o atributo name valor iguala str2

　　　　 3de um objeto existe um método sayIt, que retorna uma string equivalente ao atributo greeting valor + ‘, ‘ +name atributo valor

function createModule(str1, str2) {
   var obj = {
     greeting : str1,
     name   : str2,
     sayIt  : function(){
       //as duas propriedades precisam ter this no início
       return this.greeting+", "+this.name;
     }
   };
   return obj;
 }
//método de construtor
function createModule(str1, str2) {
  function Obj(){
    this.greeting = str1;
    this.name = str2;
    this.sayIt = function(){
      return this.greeting + ', ' + this.name;
    };
  }
  return new Obj();
}
//composição de construtor e protótipo
function createModule(str1, str2) {
  function CreateMod(){
    this.greeting = str1;
    this.name = str2;
  }
  CreateMod.prototype.sayIt = function(){
    return this.greeting + ', ' + this.name;
  }
  return new CreateMod();
}

cinco, sabendo que fn é uma função pré-definida, implemente a função curryIt, após a chamada, deve atender aos seguintes condições:

　　　　　 1depois de retornar uma função a, o valor de length da a é1ou seja, declare explicitamente a a receber um parâmetro)

　　　　　 2depois de chamar a, é retornado uma função b, o valor de length da b é 1

　　　　　 3depois de chamar b, é retornado uma função c, o valor de length da c é 1

　　　　　 4depois de chamar c, o resultado da chamada é o mesmo que o valor de retorno da chamada fn

　　　　　 5os argumentos do fn são os argumentos de chamada das funções a, b, c

exemplo de entrada:

var fn = function (a, b, c) {return a + b + c}; curryIt(fn)(1)(2)(3);
function curryIt(fn) {
   //obtenha a quantidade de argumentos do fn
   var n = fn.length;
   //declare um array args
   var args = [];
   //retorne uma função anônima
   return function(arg){
     //coloque os parâmetros no final do curryIt em um array
     args.push(arg);
     //se o número de argumentos em args for menor que o número de argumentos da função fn,
     //então execute arguments.callee（que serve para referenciar a função em execução, neste caso, o currículo retornado).
     //de outra forma, retorne o resultado da chamada do fn
     if(args.length < n){
      return arguments.callee;
     else return fn.apply("",args);
   }
 }
function curryIt(fn) {
  return function a(xa){
    return function b(xb){
      return function c(xc){
        return fn.call(this,xa,xb,xc);
      };
    };
  };
}

Sexto, exibir a posição do elemento no array

function indexof(arr,item){
  for(var i = 0,len = arr.length;i<len;i++){
    var ite = arr[i];
    if(ite == item){
      console.log(ite == item);
      return i;
    }else{
      return -1;
    }
  }
}
function indexof(arr,item){
  return arr.indexOf(item);
}

Sétimo, somar o array

function sum(arr) {
  return eval(arr.join("+"));
};

Oitavo, remover o elemento especificado

  function remove(arr, item) {
    for(var i=0, m=arr.length, res=[]; i<m; i++){
      if(item === arr[i]) continue;
      else res.push(arr[i]);
    }
    return res;
  }
function remove(arr, item) {
  var newA=arr.slice(0);
  for(var i=newA.indexOf(item);i>-1;i=newA.indexOf(item)){
    newA.splice(i,1);
  }
  return newA;
}

Resumo

Aqui termina a sumário dos problemas lógicos comuns em JavaScript, não sei se todos aprenderam. O conteúdo deste artigo pode ajudar na aprendizagem ou no trabalho, e se tiverem dúvidas, podem deixar comentários para trocar ideias, obrigado pelo apoio ao Tutorial Grito.