| Permalink | 
| Permalink |
function Product(name,price) {
this.name = name;
this.price = price;
this.discount = 0;
}
var sneakers = new Product("Sneakers",20); // {name:"Sneakers",price:20,discount:0}
var tshirt = new Product("T-shirt",10); // {name:"T-shirt",price:10,discount:0}function badProduct(obj) { obj.discount+= 20; ... }
function generalDiscount(obj) { obj.discount+= 10; ... }
function distributorDiscount(obj) { obj.discount+= 15; ... }if(obj.discount>80) obj.discount = 80;function Product(name,price) {
var _name=name, _price=price, _discount=0;
this.getName = function() { return _name; }
this.setName = function(value) { _name = value; }
this.getPrice = function() { return _price; }
this.setPrice = function(value) { _price = value; }
this.getDiscount = function() { return _discount; }
this.setDiscount = function(value) { _discount = value; }
}getDiscount (accessor) and setDiscount (mutator) methods. The problem is that most of the members behave like common variables, just the discount needs special care here. But good design requires encapsulation of every data member to keep the code extensible. So you need to add lots of code that does nothing. This is also a bad design, aboilerplate antipattern. Sometimes you can't just refactor the fields to methods later (the eshop code may grow large or some third-party code may depend on the old version), so the boilerplate is lesser evil here. But still, it is evil. That's why properties were introduced into many languages. You could keep the original code, just transform the discount member into a property with get and set blocks:function Product(name,price) {
this.name = name;
this.price = price;
//this.discount = 0; // <- and="" below="" code="" line="" refactor="" remove="" span="" the="" this="" with="">
var _discount; // private member
Object.defineProperty(this,"discount",{
get: function() { return _discount; },
set: function(value) { _discount = value; if(_discount>80) _discount = 80; }
});
}
// the client code
var sneakers = new Product("Sneakers",20);
sneakers.discount = 50; // 50, setter is called
sneakers.discount+= 20; // 70, setter is called
sneakers.discount+= 20; // 80, not 90!
alert(sneakers.discount); // getter is calledfor(var i in theObject); if false, it will not be iterated, but it is still accessible as publicObject.getOwnPropertyDescriptor().var o = {};
Object.defineProperty(o,"test",{
value: "a",
configurable: true
});
console.log(Object.getOwnPropertyDescriptor(o,"test")); // check the settings
for(var i in o) console.log(o[i]); // nothing, o.test is not enumerable
console.log(o.test); // "a"
o.test = "b"; // o.test is still "a", (is not writable, no error)
delete(o.test); // bye bye, o.test (was configurable)
o.test = "b"; // o.test is "b"
for(var i in o) console.log(o[i]); // "b", default fields are enumerableconfigurable: false to all properties). Use yourObject.isSealed() to detect this feature on the object. The seal is shalow (read below).writable: false to all properties with data descriptor). Setter's writable property is not affected (since it doesn't have one). The freeze is shalow: it means that if the property is Object, its properties ARE NOT frozen (if you wish to, you should perform something like "deep freeze", similar to deep copy - cloning). Use yourObject.isFrozen() to detect it.
| Permalink |
| Permalink |
| Permalink |
| Permalink |
| Permalink |
| Permalink |
| Permalink |
IEnumerable, allowing any typed loopable collection to be queried in a type-safe manner. These queries rely on compiled .Net methods, not Expressions.IQueryable, allowing the construction of Expression Trees that can be translated by the underlying implementation.DataContext. This is a DataAccess technology built by the C# team. It just works.ObjectContext. This is a DataAccess technology built by the ADO.Net team. It is complex, powerful, and harder to use than Linq To Sql.System.Xml . So MS re-wrote it and took advantage of the re-write to introduce some methods that make it easier to use LinqToObjects against Xml.IEnumerable result =
from c in myCustomers
where c.Name.StartsWith("B")
select c.Name System.Linq.Expressions.Expression. You really need to understand these to use Linq well. There are three parts: A parameter list, an arrow, and a method body.IEnumerable result = myCustomers.Where( c => c.Name.StartsWith("B") ).Select(c => c.Name) myCustomers.Select(c => new
{
Name = c.Name;
Age = c.Age;
})//The compiler will determine that names is an IEnumerablevar names = myCustomers.Select(c => c.Name);
| Permalink |
