相关疑难解决方法(0)

可能重复:
在Javascript中使用'prototype'与'this'？

我对这两种向函数添加方法的方式感到困惑.让我举个例子来解释一下.

var foo = function(){
    this.bar = function(){alert('I am a method')}
}

foo.prototype.baz = function(){alert('I am another method')}

var car = new foo();

现在,在这一点上我们可以使用汽车的baz和bar方法.好吧,但它们之间有什么区别.为函数原型或它的构造函数添加方法的细微差别是什么.

谢谢..

我想知道,JavaScript中的prototyped和非原型方法有什么不同？非常感谢任何帮助.

假设我有一个类和一些静态辅助方法,如下所示:

function MyClass (myVar) {
    this.myVar = myVar;

    this.replaceMe = function (value) {
        // this will fail
        this = MyClass.staticHelper( value );

        return this;
    }

    this.revealVar = function () {
        alert( this.myVar );
    }
}

MyClass.staticHelper = function (instance, value) {
    return new MyClass( instance.myVar + value );
}

我想做的是这样的:

var instance = new MyClass( 2 );

instance.revealVar(); // alerts 2
instance.replaceMe( 40 ).revealVar(); // alerts 42

原因是我的类有一个稍微复杂的结构,我不想每次手动分配所有内部变量,而是替换整个对象.有一个简单的方法吗？

<script>
var mango =  new Object ();
mango.color = "yellow";
mango.shape= "round";
mango.sweetness = 8;
Object.prototype.howSweetAmI = function () {
console.log("Hmm Hmm Good");
}
console.log(mango); 
</script>

题:

我可以改变这一行: Object.prototype.howSweetAmIto mango.howSweetAmI,并且它们都可以工作.但它们之间有什么区别？通常我们使用哪种方式来创建方法？

我现在正在测试一个简单的Javascript"类".我注意到我的私有函数中的"this"并没有指向对象本身,而是指向全局范围(窗口).

为什么？

信息:我想保持模式私有,所以我使用var模式而不是this.mode.我还希望将两个内部函数保持为私有,因此用户无权访问它.我基本上使用.prototype来向myStorage添加公共函数来访问私有成员.

我的代码:

var myStorage = function(mymode) {
    var mode = mymode;
    function privateFunctionA() {
      // access this.mode to read mymode from constructor but 
      // this is pointing to window
    };

    function privateFunctionB() {
      // access this.mode to read mymode from constructor but 
      // this is pointing to window
    };

    // check for indexeddb, websql and localstorage
    if(mymode == 'A') {
      privateFunctionA();
    } else {
      privateFunctionB();
    }
};
myStorage.prototype.publicFunc = function() {
  console.log(this.mode); // does this work?
}

var …

作为ac#/ .net dev,我喜欢在业余时间玩JavaScript - 创建我自己的库/框架等.不可否认,它们并不多(实际上只不过是松散的功能集合),但其目的是学习; 不供其他人使用.

我通常以这种方式扩展一个基本的JavaScript对象

obj = function () {
    //basic object stuff
    this.method = function () {
        //other stuff
    };
    return this;
};

这允许我一起创建其他对象和链方法,这非常灵活:

obj('arg1').method();

两个例子:jQuery Knock-off,List-Item Sorter

但是,我最近看到,在比我自己更多的功能代码中,对象通过这种方式实现了相同的功能:

function obj(){
    //stuff
}
obj.prototype.method = function () {
    //stuff
};

示例:Reddit Chrome扩展程序

两种方式似乎都达到了同样的目的,而且我不会偏向任何一种语法.是否存在一种比另一种更有用的特殊情况？这些方法提供了什么使它们比另一种更令人满意？

编辑

请考虑以下代码:

var dice = function (sides) {
    this.roll(){
        return 4 //guaranteed to be random
    }
};

var d1 = dice(6);
d1.roll()  // 4;
var d2 = dice(20);
d2.roll()  // …

我有课

function Foo(a) {
  this.a = a;
  this.bar = function () {
    console.log(this.a);
  };
  this.buz = function () {
    this.a();
    console.log('bzz');
  };
}

我会有很多这类课程.我应该将方法移动到原型吗？

function Foo(a) {
  this.a = a;
}
Foo.prototype = {
  bar: function () {
    console.log(this.a);
  },
  buz: function () {
    this.a();
    console.log('bzz');
  }
}

我想创建一个允许我有各种方法的Javascript类/对象:

模型类

• Model.all() »静态方法
• Model.find() »静态方法
• Model delete() »实例方法
• Model save() »实例方法
• Model.create() »static返回一个新的Model实例

对于静态方法,我可以使用:

Model.staticMethod(){ method }

例如,方法更好用:

function Model(){
    this.instanceMethod = function(){}    
}

然后创建一个新实例

还是用原型？

var m = function Model(){

}

m.prototype.method() = function() {
}

现在让我们说我想创建一个基于Model的新类,如何继承它的原型以及它的静态方法？

编辑:

为了避免混淆,这或多或少是我想创造的:

http://activejs.org/activerecord/index.html和http://activejs.org/activerecord/ActiveRecord/Model/index.html

我可以使用类似的东西定义一个新模型

var User = ActiveRecord.create({
    username: '',
    password: '',
    post_count: 0,
    profile: ''
}

然后创建一个实例

var jessica = User.create({
    username: "Jessica",
    password: "rabbit"
});

使用实例方法

jessica.save();

还有班级方法:

User.findByUsername('Jessica');

class My {

  constructor() {
    this.myMethod1 = function(){};
  }

  myMethod2() {

  }
}

那么myMethod1和myMethod2之间有什么区别吗？

我有一个被调用的对象Grid,我用new它来创建它的实例.我希望能够从外部调用它的方法.

这是(简化)对象:

var Grid = function() {
    this.table = createTable();

    function createTable() {
        // ...
    };

    function setSelectedLine(line) { // this one should be public
        // ...
    };
};

var g = new Grid();
g.setSelectedLine(anyLine); // TypeError: g.setSelectedLine is not a function

我发现其他主题有类似的问题,但他们使用非常不同的对象结构.是否有可能将该方法公之于众,而无需重写所有内容？真正的对象实际上比那更大.