小编Pet*_*ger的帖子

根据各种来源(2ality,esdiscuss),应该能够将mixins添加到类中:

编辑发现类方法不可枚举,因此无法工作.编辑了下面的代码,但仍然没有快乐

class CartoonCharacter {
  constructor(author) {
    this.author = author;
  }

  drawnBy() {
    console.log("drawn by", this.author);
  }
}

// THIS CANNOT WORK
// class methods are not enumerable
// class Human {
//  haveFun() {
//    console.log("drinking beer");
//  }
// }

let Human = Object.create({}, {
  haveFun:   {
    enumerable: true,
    value: function () {
      console.log("drinking beer");
    }
  }
});

class Simpson extends Object.assign(CartoonCharacter, Human) {
  constructor(author) {
    super(author);
  }
}


let homer = new …

我知道要查找 javascript 中是否未声明变量，我可以使用if (typeof variable === 'undefined'). 如果我将变量声明为 undefined ( var variable = undefined)，则 if 语句仍返回 true。在 JavaScript 中，是否有可能找到未声明的变量和值为 undefined 的变量之间的区别？我知道它们很相似，但是这样做const variable = undefined然后variable = "something else"会抛出错误，所以它们一定是不同的。

const variable = undefined

if (typeof variable === 'undefined') {
  console.log('"variable" is undefined')
}

if (typeof undeclaredVariable === 'undefined') {
  console.log('"undeclaredVariable" is undefined')
}

我不想使用 try catch 块，因为我希望能够基于此分配另一个常量。我想要一个这样的解决方案：const isVariableDeclared = variable === undeclared，除非undeclared在 javascript 中不存在。我知道我可以将 let 与 try catch 块一起使用，但我正在寻找更优雅的东西。

我有一个包含未知数量的其他对象的对象.每个(子)对象可以包含布尔值作为字符串,我想将它们更改为实际的布尔值.这是一个示例对象:

var myObj = {
  my1stLevelKey1: "true",
  my1stLevelKey2: "a normal string",
  my1stLevelKey3: {
    my2ndLevelKey1: {
      my3rdLevelKey1: {
        my4thLevelKey1: "true",
        my4thLevelKey2: "false"
      }
    },
    my2ndLevelKey2: {
      my3rdLevelKey2: "FALSE"
    }
  }
}

我最终想要的是:

var myObj = {
  my1stLevelKey1: true,
  my1stLevelKey2: "a normal string",
  my1stLevelKey3: {
    my2ndLevelKey1: {
      my3rdLevelKey1: {
        my4thLevelKey1: true,
        my4thLevelKey2: false
      }
    },
    my2ndLevelKey2: {
      my3rdLevelKey2: false
    }
  }
}

重要的是数字子对象/级别是未知的.如何使用经典JavaScript或Mootools有效地做到这一点？

作为RPG游戏后端的一部分,我希望能够对角色应用临时效果.这些效果的性质可能会有很大差异,但我想保持定义它们的方法非常简单.

我正在使用自定义事件处理作为mixin:

var EvtObject = {};
$rpg.Event.enable(EvtObject); // Add the 3 methods and set EvtObject._events = {}

我想将Auras(临时效果)定义为具有事件处理代码的构造函数:

var MyAura = function(any, args){
  this.group = "classification";
  this.on( "tick", function(){} );
  this.on( "remove", function(){} );
};

然后应用为MyCharacter.addAura(new MyAura(any, args));.如您所见,我希望该this.on()函数在构造函数中可用.如果我使用mixin($rpg.Event.enable(MyAura.prototype))扩展MyAura原型,那么MyAura的每个实例都会引用_events原型中的相同对象.

我想知道以下解决方案是否是良好的做法:

Aura.create = function(Constructor)
{
    Constructor.prototype = Aura.getPrototype(); // Aura specific prototype

    return function()
    {
        var newAura = Object.create(Constructor.prototype);
        $rpg.Event.enable( newAura );
        Constructor.apply( newAura, arguments );
        return newAura;
    };

};

// Then creating new …

我正在尝试理解 javascript 中的 mixin 以及到目前为止我读过的所有示例和文章都讨论添加方法而不是属性。

我发现Alex Jover Morales 的文章非常有用，我稍微修改了他的示例，在此处的 mixin 中包含了一个额外的 mixin 和具有新属性的构造函数。

我在下面所做的事情是反模式吗？mixin 中的构造函数和属性有问题吗？在每个 mixin 的构造函数中调用 super() 是否存在问题？

const PlayMixin = superclass => class extends superclass {

  constructor(args) {
    let { favouriteGame } = args        
    super(args);
    this.favouriteGame=favouriteGame;
  }

  play() {
    console.log(`${this.name} is playing ${this.favouriteGame}`);
  }
};


const FoodMixin = superclass => class extends superclass {

  constructor(args) {
    let { genericFood } = args        
    super(args);
    this.genericFood=genericFood;
  }

  eat() {
    console.log(`${this.name} is eating ${this.genericFood}`);
  }

  poop() {
    console.log("Going to …

最近，我看到了两篇关于 mixin 的文章。这让我在哪个比另一个更好之间感到困惑。

第一个来自mdn

var calculatorMixin = Base => class extends Base {
  calc() { }
};
var randomizerMixin = Base => class extends Base {
  randomize() { }
};

class Foo { }
class Bar extends calculatorMixin(randomizerMixin(Foo)) { }

来自https://javascript.info/mixins 的第二个

let sayMixin = {
  say(phrase) {
    alert(phrase);
  }
};

let sayHiMixin = {
  __proto__: sayMixin, // (or we could use Object.create to set the prototype here)

  sayHi() {
    // call parent method
    super.say(`Hello ${this.name}`);
  }, …

我需要一些帮助，因为我对 JavaScript 还很陌生。

我想创建一个计算会员费的函数

我尝试在 JavaScript 中创建一个函数来检查是否只选择了一个选项，但我不知道如何制作它以便我可以在用户有资格获得一个以上或所有折扣的情况下计算费用。目前还没有针对年龄条件的 JS（60 到 80 岁之间），因为我不确定如何去做。

function feeCalc() {
  var ans = document.getElementById("answer");
  if (document.getElementById('medicalCond-yes').checked) {
    ans.value = calculate('medicalCond-yes');
  }
  if (document.getElementById('empstatus-yes').checked) {
    ans.value = calculate('empstatus-yes');
  }
  if (document.getElementById('empstatus-no').checked) {
    ans.value = calculate('empstatus-no');
  }
  if (document.getElementById('medicalCond-no').checked) {
    ans.value = calculate('medicalCond-no');
  }
}

function calculate(action) {
  var standardRate = 10;
  var ageRate = 0.1;
  var medicalRate = 0.4;
  var unemployedRate = 0.3;
  var result;
  switch (action) {
    case 'medicalcond-yes':
      discount = (standardRate * studentRate);
      result = …

我试图从字符串形式的对象中挑选出所有值。我已经创建了正则表达式，但我仍然遇到无法删除引号并碰壁的问题......

这是我得到的结果与期望结果的比较的代码：

const regex = /(?:"([^"]+)\")|([^=",{}.]+)/g
const string = 'obj{a="0",b="1",domain="a-ss.test.io:666",f="g",range="3.594e-04...4.084e-04"}'

const matches = string.match(regex)
console.log(matches)

这是结果数组：

[
    "obj",
    "a",
    "\"0\"",
    "b",
    "\"1\"",
    "domain",
    "\"a-ss.test.io:666\"",
    "f",
    "\"g\"",
    "range",
    "\"3.594e-04...4.084e-04\""
]

虽然我想要的结果是：

[
    "obj",
    "a",
    "0",
    "b",
    "1",
    "domain",
    "a-ss.test.io:666",
    "f",
    "g",
    "range",
    "3.594e-04...4.084e-04"
]

有谁知道如何从返回的每个数组值中删除引号？

我想将具有相同属性的 2 个对象合并到一个数组中。

以此为例：

object1 = {"id":1,
           "name":name1,
           "children":[{"id":2,"name":name2}]
          };
object2 = {"id":3,
           "name":name3,
           "children":[{"id":4,"name":name4}]
          };
object3 = {"id":1,
           "name":name1,
           "children":[{"id":6,"name":name6}]
          };
var result = Object.assign(result,object1,object2,object3);

预期结果：

JSON.stringify([result]) =[
                           {"id":1,
                            "name":name1,
                            "children":[{"id":2,"name":name2},
                                       {"id":6,"name":name6}]
                           },
                           {"id":3,
                            "name":name3,
                            "children":[{"id":4,"name":name4}]
                           }
                          ]

实际结果：

JSON.stringify([result]) = [
                            {"id":3,
                             "name":name3,
                             "children":[{"id":4,"name":name4}]
                            }
                           ]

似乎 Object.assign() 不是要走的路......因为它会覆盖，我不希望它覆盖，我希望它们合并。有没有正确的方法来做到这一点？

这些是我的一些函数，我需要编写一个通用函数来查看函数运行是否没有错误。我尝试使用 try/catch 方法。但我只能对每个函数单独执行此操作。

function fisrt(){
 console.log("First");
};

function second(){
 console.log("Second");
}

function third(){
 console.log("Third");
}
fisrt();
second();
third();

我在 try-catch 中编写每个函数。有没有一种方法可以为所有函数编写一个通用的 try-catch。

try {
     (function first() {
       console.log("ffgdf")
    })();

 }catch (e) {
      console.log( "won't work" );
    }