Javascript 返回函数的返回对象

我需要用JavaScript编写一个函数，它接受一个数字并返回一个返回可链接函数的对象（不使用OOP）

例如：

func(3).not().not().equals(4)

将输出

false

以及：

将输出：

true

这是我写的代码：

const func = (obj) => { 
  const obj2 = {
    not: () => {
      return !obj
    },
    equals: (num) => {
     return obj === num
   }
 }
  return obj2 
}

当我调用

func（3）.not（）

或

func（5）.equals（5）

时，它可以工作，但不允许我链接函数，因此调用

func（5）.not（）.equals（5）

返回一个错误，说明这不是函数

---

我在这里看不到什么

您可以将要返回的对象作为接口并存储值和否定

var对象={
func：函数（值）{
object.left=值；
返回对象；
},
不是：函数（）{
object.negation=！object.negation；
返回对象；
},
等于：函数（值）{
var result=value==object.value；
返回object.negation？！结果：结果；
}
},
func=object.func；
log（func（3）.not（）.not（）.equals（4））您可以将要返回的对象作为接口并存储值和否定


var对象={
func：函数（值）{
object.left=值；
返回对象；
},
不是：函数（）{
object.negation=！object.negation；
返回对象；
},
等于：函数（值）{
var result=value==object.value；
返回object.negation？！结果：结果；
}
},
func=object.func；
log（func（3）.not（）.not（）.equals（4））您可以使用闭包来存储初始输入和操作状态：


const func=（输入）=>{
让我们不要误会
常量对象={
不是：（）=>{
不
返回obj
},
等于：（num）=>{
不返回？输入！==num:input==num
}
}
返回obj；
}
console.log（func（5）.not（）.equals（5））
console.log（func（5）.not（）.not（）.equals（5））
console.log（func（5）.not（）.equals（4））
console.log（func（5）.not（）.not（）.equals（4））
您可以使用闭包来存储初始输入和操作状态：


const func=（输入）=>{
让我们不要误会
常量对象={
不是：（）=>{
不
返回obj
},
等于：（num）=>{
不返回？输入！==num:input==num
}
}
返回obj；
}
console.log（func（5）.not（）.equals（5））
console.log（func（5）.not（）.not（）.equals（5））
console.log（func（5）.not（）.equals（4））
console.log（func（5）.not（）.not（）.equals（4））
这是一种非常奇怪的函数组合方式。让我们想想到底发生了什么

func（3）.not（）.not（）.equals（4）
//相当于
不（不等于（4）（3）））
//在哪里
常数not=x=>！x；
常数=x=>y=>x==y；

实现此链的最简单方法如下所示


const equals=x=>toBool（y=>x==y）；
常数toBool=func=>({
不是：（）=>toBool（x=>！func（x）），
func
});
常量example1=等于（4）.not（）.not（）.func（3）；
常数example2=等于（5）.func（5）；
console.log（示例1）；//假的
console.log（示例2）；//真的
这是一种非常奇怪的函数组合方式。让我们想想到底发生了什么

func（3）.not（）.not（）.equals（4）
//相当于
不（不等于（4）（3）））
//在哪里
常数not=x=>！x；
常数=x=>y=>x==y；

实现此链的最简单方法如下所示


const equals=x=>toBool（y=>x==y）；
常数toBool=func=>({
不是：（）=>toBool（x=>！func（x）），
func
});
常量example1=等于（4）.not（）.not（）.func（3）；
常数example2=等于（5）.func（5）；
console.log（示例1）；//假的
console.log（示例2）；//true
要使用包装新值的相同方法返回另一个对象，只需再次调用
func
：


const func=（obj）=>{
常数obj2={
不是：（）=>{
返回函数（！obj）
//    ^^^^^^^^^^^^^^^^^
},
等于：（num）=>{
返回对象===num
}
}
返回obj2
}
console.log（func（3）.not（）.not（）.equals（4））
console.log（func（5）.equals（5））
console.log（func（3）.not（））
要使用包装新值的相同方法返回另一个对象，只需再次调用
func
：


const func=（obj）=>{
常数obj2={
不是：（）=>{
返回函数（！obj）
//    ^^^^^^^^^^^^^^^^^
},
等于：（num）=>{
返回对象===num
}
}
返回obj2
}
console.log（func（3）.not（）.not（）.equals（4））
console.log（func（5）.equals（5））
log（func（3）.not（））
为什么会这样？not和equals返回布尔值，它们没有equals或not属性。如果它们自己返回实例，您也必须提供一个方法来获得结果。
.not（）
需要返回一个对象。如果你用一个类来编写代码会更容易些。“不使用OOP”-这毫无意义。使用对象和方法是面向对象的。“我需要写…”我怀疑你是否需要这样写你的代码。你想这样写你的代码，但这是个坏主意。为什么会这样？not和equals返回布尔值，它们没有equals或not属性。如果它们自己返回实例，您也必须提供一个方法来获得结果。
.not（）
需要返回一个对象。如果你用一个类来编写代码会更容易些。“不使用OOP”-这毫无意义。使用对象和方法是面向对象的。“我需要写…”我怀疑你是否需要这样写你的代码。您想这样编写代码，但这不是一个好主意。谢谢！我试试这个！非常感谢。我试试这个！令人惊叹的！这就是我想做的。非常感谢。我发现闭包看起来有多像对象的私有状态总是令人着迷（当然，反之亦然，这取决于你从哪里看）。太棒了！Th
const func = (obj) => { 
  const obj2 = {
    not: () => {
      return !obj
    },
    equals: (num) => {
     return obj === num
   }
 }
  return obj2 
}