Wie man eine Eigenschaft/Methode aufrufbar macht oder nicht?

Question

Ich möchte diese Funktionalität erreichen:

1. ich ein Objekt var obj = {};

2. Ich habe drei Angebote in diesem obj, obj.zero & obj.one & obj.binaryString

   • obj.zero & obj.one sind Methoden während obj.binaryString haben ist eine Zeichenfolge

Wenn ich die Eigenschaften Kette, mag ich sie ihre jeweilige Stelle nach binaryString hinzuzufügen. So zum Beispiel:

obj.one.zero.zero.one => macht obj.binaryString = 1001

obj.one.zero.one.one.zero => macht obj.binaryString = 10110

Ich habe die obige Funktionalität mit diesem erreicht:

function Binary() { 
    var obj = { binaryString: '' }; 

    Object.defineProperty(obj, 'zero', { 
     get: function() { 
      obj.binaryString += '0'; 
      return obj; 
     } 
    }); 

    Object.defineProperty(obj, 'one', { 
     get: function() { 
      obj.binaryString += '1'; 
      return obj; 
     } 
    }); 

    return obj; 
} 

var binary = new Binary(); 
binary.one.zero.zero.one // => obj.binaryString becomes '1001' 

Jetzt möchte ich Loggen Sie sich die ausgefüllten binaryString, plus und additionalString, die ich mit dem folgenden Code erreicht haben:

// placed inside Binary constructor function 
Object.defineProperty(obj, 'log', { 
    get: function() { 
     return function(additionalString) { 
      console.log(obj.binaryString + additionalString); 
     }; 
    } 
}); 

Also mit diesem aktuellen Code kann ich dies tun:

binary.one.zero.one.zero.one.log(' is the answer'); 
// logs out `10101 is the answer` 

Was ich tun möchte, ist der log loswerden und machen die one und zero Methoden aufrufbaren oder nicht, so kann ich dies erreichen Funktionalität:

binary.one.one.zero.one(' is the result') 
// => logs out `1101 is the result` 

Wie kann ich das tun?

Ich glaube, es eine ähnliche Funktionalität wie Chalk Werke wäre:

chalk.blue.bold('Hello world!'); 
// `blue` is not invoked here but it adds the color blue to the style 

chalk.blue('Hello world!'); 
// `blue` IS invoked here. It adds blue to the style and returns the stylized string 

Answer 1

Nur Sprechen Sie die obj als Funktion und drucken, was immer Sie wollen.

function Binary() { 
 
    var obj = function(msg){ console.log(msg+this.binaryString) }; 
 
    obj.binaryString = '' 
 

 
    Object.defineProperty(obj, 'zero', { 
 
     get: function() { 
 
      obj.binaryString += '0'; 
 
      return obj; 
 
     } 
 
    }); 
 

 
    Object.defineProperty(obj, 'one', { 
 
     get: function() { 
 
      obj.binaryString += '1'; 
 
      return obj; 
 
     } 
 
    }); 
 

 
    return obj; 
 
} 
 

 
var binary = new Binary(); 
 
binary.one.zero.zero.one.zero(" is the result ")

Answer 2

Ich möchte darauf hinweisen, dass das, was Sie tun, eine sehr schlechte/gefährliche Idee ist: missbrauchen Leseeigenschaften des Objekts mutieren selbst für Ärger bittet. Du wirst es vielleicht nicht sehen, aber es wird zu Schmerzen und Herzschmerz in Form von schwer zu findenden Käfern und verworrenen Mustern führen.

Was Sie können tun, ist, das ist nicht so gefährlich ist, ist stattdessen das Objekt mutiert selbst zurückgeben eine neue Instanz von Binary mit jedem Aufruf #one oder #zero.Zum Beispiel:

function Binary(s) { 
    this.binaryString = s || '' 
} 
Object.defineProperty(Binary.prototype, 'zero', { 
    get: function() { 
    return new Binary(this.binaryString + '0') 
}}) 
Object.defineProperty(Binary.prototype, 'one', { 
    get: function() { 
    return new Binary(this.binaryString + '1') 
}}) 

Dies ist der Ansatz von Chalk, und wird viel sicherer und weniger fehleranfällig sein.

UPDATE:

Nach über Ihr Problem zu denken, und Ihre Frage zu sehen, ich denke, der beste Ansatz überhaupt gar keine Klassen zu verwenden. Sie können dieses Problem mit einem reinen funktionsbasierten Ansatz lösen. Es ist unveränderlich, es ist sicher und ich glaube, es ist weniger verwirrend. Hier ist es in ES5:

function bin(str) { 
    if(!str) str = '' 
    function f(msg) { return str + ' ' + msg } 
    return Object.defineProperties(f, { 
    zero: { 
     get: function() { 
     return bin(str + '0') 
     }, 
    }, 
    one: { 
     get: function() { 
     return bin(str + '1') 
     }, 
    }, 
    }) 
} 

Und wenn Sie ES6 verwenden können (aka ES2015), können Sie machen es viel kompakter:

function bin(str = '') { 
    return Object.defineProperties(msg => `${str} ${msg}`, { 
    zero: { get() { return bin(str + '0') } }, 
    one: { get() { return bin(str + '1') } }, 
    }) 
} 

Sie würde es so verwenden:

bin().one.zero.one.zero('is the answer') // '1010 is the answer'