Javascript对象属性和函数

在JavaScript中，我看到了几种不同的方式，某些任务可以在一个对象中执行，例如，下面的对象Egg

有谁能告诉我每一个之间的区别，为什么我会使用一个而不是另一个等等

 var Egg = function(){

    //Properties

    var shell = "cracked" // private property 

    this.shell = "cracked" // public property

    shell: "cracked" // what is this??

    //functions

    function cook(){

        //standard function
    }

    cook: function(){
        //what kind of function is this?
    }

    //not sure what this is

    details: {
        //What is this? an array :S it holds 2 elements?
        cost: 1.23,
        make: 'Happy Egg';
    }




}

---

您正在混合对象属性声明和简单javascript语句之间的语法

// declare an object named someObject with one property
var someObject = {
    key: value
};

// declare an anonymous function with some statements in it
// and assign that to a variable named "someFunction"
var someFunction = function () {
    // any javascript statements or expressions can go here
};

---

JavaScript在对象和函数之间有一个关键区别。对象包含一组数据（包括函数），函数可以用来创建或修改对象，但它们本质上不是一回事。JavaScript中的OOP基于将函数用作类。例如，以以下课程为例：

Test = function(){
    this.value = 5;
}

如果只调用函数

Test（）

，那么什么也不会发生。即使您说

var x=Test（）

，x的值也将

未定义

。然而，使用

new

关键字，奇迹发生了！因此，如果我们说

var x=newtest（）

，那么现在变量

x

将包含一个测试对象。如果执行

console.log（x.value）

，它将打印5

这就是我们如何使用函数来创建对象。在语法上还有一个不同的键——函数可以包含您想要的任何类型的JavaScript块，无论是if语句还是for循环，或者您所拥有的任何东西。但是，在声明对象时，必须使用

key:value

语法

---

希望能把事情弄清楚一点

您的代码片段不太有效，但它引发了以下几点问题：

属性初始值设定项、对象初始值设定项 你问过什么是

shell:cracked

。这是一个属性初始值设定项。您可以在（也称为“对象文字”）中找到它们，其编写方式如下：

var obj = {
    propName: "propValue"
};

// Constructor function
function EverUpwards() {
    var counter = 0;

    this.increment = function() {
        return ++counter;
    };
}

// Usage:
var e = new EverUpwards();
console.log(e.increment()); // "1"
console.log(e.increment()); // "2"

这相当于：

var obj = {};
obj.propName = "propValue";

以上两种方法都使用名为

propName

的属性创建一个对象，该属性具有字符串值

“propValue”

。请注意，

此

不在其中

功能 有两个地方的函数通常是针对对象的：

构造函数 有一些构造函数，它们是通过调用的函数。下面是一个例子：

// Constructor function
function Foo(name) {
    this.name = name;
}

// Usage
var f = new Foo("Fred");

注意此处使用的关键字

this

。这就是你所看到的（最有可能）。当您通过

new

调用构造函数时，

此

引用由

new

操作符创建的新对象

<>代码>这个< /C>是Javascript中的一个很滑的概念（与C++中的代码< > /<代码>完全不同），我在博客上推荐这两个（java）帖子：

建造商/工厂职能 您不必使用构造函数和

new

，另一种模式使用“builder”或“factory”函数：

// A factory function
function fooFactory(name) {
    var rv = {}; // A new, blank object

    rv.name = name;

    return rv;
}

// Usage
var f = fooFactory("Fred");

私有财产 你在问题中提到了“私人”财产。JavaScript根本没有私有属性（但它们正在开发中）。但您可以看到，人们通过在执行上下文（通常是对构造函数或工厂函数的调用）上将对象上使用的函数定义为闭包来模拟它们，其中包含其他人看不到的变量，如下所示：

var obj = {
    propName: "propValue"
};

// Constructor function
function EverUpwards() {
    var counter = 0;

    this.increment = function() {
        return ++counter;
    };
}

// Usage:
var e = new EverUpwards();
console.log(e.increment()); // "1"
console.log(e.increment()); // "2"

（该示例使用构造函数，但您可以使用工厂函数执行相同的操作。）

请注意，即使我们分配给

increment

的函数可以访问

计数器

，其他任何函数都不能访问。因此，

计数器

实际上是私有财产。这是因为函数是一个闭包。更多信息：

当然可以，本

这是JavaScript动态性的本质。 首先，我们来看看基础知识——如果你来自一个理解基于类的语言的地方，比如说Java或C++/C#，那么最有意义的是构造函数模式，它很早就包含了：

function Egg (type, radius, height, weight) {
    // private properties (can also have private functions)
    var cost = (type === "ostrich") ? 2.05 * weight : 0.35 * weight;

    // public properties
    this.type = type;
    this.radius = radius;
    this.height = height;
    this.weight = weight;
    this.cracked = false;

    // this is a public function which has access to private variables of the instance
    this.getCost = function () { return cost; };
}

// this is a method which ALL eggs inherit, which can manipulate "this" properly
// but it has ***NO*** access to private properties of the instance
Egg.prototype.Crack = function () { this.cracked = true; };


var myEgg = new Egg("chicken", 2, 3, 500);

myEgg.cost; // undefined
myEgg.Crack();
myEgg.cracked; // true

那很好，但是有时候有更简单的方法来解决问题。 有时候你真的不需要上课

如果你只想用一个鸡蛋怎么办，因为这就是你的食谱要求的全部

var myEgg = {};  // equals a new object
myEgg.type = "ostrich";
myEgg.cost = "......";
myEgg.Crack = function () { this.cracked = true; };

那很好，但是仍然有很多重复

var myEgg = {
    type : "ostrich",
    cost : "......",
    Crack : function () { this.cracked = true; }
};

两个“myEgg”对象完全相同

这里的问题是myEgg的每个属性和每个方法都是100%公开给任何人的

解决方案是立即调用函数：

// have a quick look at the bottom of the function, and see that it calls itself
// with parens "()" as soon as it's defined
var myEgg = (function () {
    // we now have private properties again!
    var cost, type, weight, cracked, Crack, //.......

    // this will be returned to the outside var, "myEgg", as the PUBLIC interface
    myReturnObject = {
        type : type,
        weight : weight,
        Crack : Crack, // added benefit -- "cracked" is now private and tamper-proof
        // this is how JS can handle virtual-wallets, for example
        // just don't actually build a financial-institution around client-side code...
        GetSaleValue : function () { return (cracked) ? 0 : cost; }
    };

    return myReturnObject;
}());

myEgg.GetSaleValue(); // returns the value of private "cost"
myEgg.Crack();
myEgg.cracked // undefined ("cracked" is locked away as private)
myEgg.GetSaleValue(); // returns 0, because "cracked" is true

---

希望这是一个不错的开始。

Q:什么是

shell:cracked//这是什么？

a:一个错误！您所引用的JavaScript语法无效。很接近，但不是。首先，

var Egg=function（）{…}创建一个函数并将其分配给
Egg
。函数是对象，但我不认为这就是你所说的“……我下面的对象蛋……”epascarello：事实上，不是一个错误。A.尽管如此，可能还是不是他想要的。@T.J.Crowder我知道就像数百万人添加到事件处理程序中的精彩的
javascript:
。该行除了向函数中添加一些字节外，什么也不做。：）@埃帕斯卡雷洛：如果它真的这样做了，那就用一台像样的发动机吧。：-）函数是可以调用的对象<代码>函数（）。如果它们是对象，那么
typeof function（）{}
将打印“object”，但是函数有一个单独的分类（因此它打印“function”）。“JavaScript中的每个函数实际上都是一个函数对象。”它继承自对象。@威尔：根据JavaScript的技术定义，函数就是对象。这不是什么附带的东西，它是语言的一个明确的、有意的和核心的部分
typeof
之所以说“function”，是因为它比“object”更精确地描述了对象的类型，而不是因为它们不是对象。规范中对这个词的定义清楚地表明它们是对象，从“.”之类的章节中也可以清楚地看出这一点。@JamundFerguson:你还以为自己有点迂腐。：-）(