Question

有时我会听到人们说“对象的引用”，有人说“对象的实例” 有什么区别？

Answer 1

变量将引用保存到对象的实例。

实际对象是实例。

用于访问对象的变量/变量将引用保存到它。

Answer 2

对象的实例（或者，在谈论具有类的概念的语言时，或许更准确地说，是一种已经创建并存在于内存中的对象）。例如，写作时

var obj = new Foo();

然后创建了一个新的对象实例（new Foo）。

对象的引用是某种允许我们访问实例的句柄。例如，在许多语言（包括JavaScript）中，obj现在拥有对我们刚刚创建的实例的引用。

可以有许多对同一实例的引用，如

var obj2 = obj;

现在，obj和obj2都保持对同一对象的引用。

Answer 3

可以有多个对一个实例的引用。就像，嗯，通往同一个地方的许多路径。

var x="string object";
var y=x;

x和y都是对同一对象实例的两个不同（但相等）的引用。

Answer 4

在javascript中，变量是对实际实例的引用

    // create a new object from the Object constructor
    // and assign a reference to it called `firstObjRef`
    var firstObjectRef = new Object();

    // Give the object the property `prop`
    firstObjRef.prop = "im a property created through `firstObjRef`";


    // Create a second reference (called `secondObjRef`) to the same object
    var secondObjRef = firstObjRef;
    // this creates a reference to firstObjRef,
    // which in turn references the object

    secondObjRef.otherProp = "im a property created through `secondObjRef`";


    // We can access both properties from both references
    // This means `firstObjRef` & `secondObjRef` are the same object
    // not just copies

    firstObjRef.otherProp === secondObjRef.otherProp;
    // Returns true

如果将变量传递给函数，这也会起作用：


    function objectChanger (obj, val) {
         // set the referenced object;s property `prop` to the referenced
         // value of `val`
         obj.prop = val;
    }

    // define a empty object outside of `objectChanger`'s scope
    var globalObject = {};

    globalObject === {}; // true

    // pass olobalObject to the function objectChanger
    objectChanger(globalObject, "Im a string");

    globalObject === {}; // false
    globalObject.prop === "Im a string"; // true

Answer 5

我们总是使用对象的引用而不能直接使用对象，我们只能使用引用。 对象实例本身就在内存中。

当我们创建一个对象时，我们得到一个引用。我们可以创建更多参考文献：

var obj = {}; // a reference to a new object
var a = obj; // another reference to the object

Answer 6

对象是类的占用内存。引用指向该内存并且它有一个名称（你可以将其称为变量）。例如， A =新A（）; 在这里我们写“新A（）;”一些内存将被占用在系统中。 'a'是指向此内存的引用（变量），用于访问此内存中的数据。

对象在有生命时获得，意味着它占用了一些内存。参考指向对象。实例是在某个时间点指向对象的Reference的副本。

Refrence是指向对象的变量。 Object是具有一些内存的类的实例，而实例是一个变量＆amp;对象拥有的方法。

引用表示对象或变量的地址。对象是类的实例，实例意味着代表类，即对象

实例是在运行时创建的实际对象。

Answer 7

private lazy var cacheContext: CGContext? = {
    let bitmapWidth = Int(self.bounds.size.width)
    let bitmapHeight = Int(self.bounds.size.height)
    let bitmapBytesPerRow = bitmapWidth * 4
    let bitmapBytesCount = bitmapBytesPerRow * bitmapHeight
    let bitmapData = malloc(bitmapBytesCount)//calloc(bitmapBytesCount, MemoryLayout<CChar>.size)

    if bitmapData == nil {
        return nil
    }

    let bitmapInfo = CGBitmapInfo(rawValue: CGImageAlphaInfo.noneSkipFirst.rawValue).union(.byteOrder32Little)
    let context = CGContext(data: bitmapData, width: bitmapWidth, height: bitmapHeight, bitsPerComponent: 8, bytesPerRow: bitmapBytesPerRow, space: CGColorSpaceCreateDeviceRGB(), bitmapInfo: bitmapInfo.rawValue)

    context?.setLineCap(CGLineCap.round)
    context?.setFillColor(UIColor.white.cgColor)
    context?.fill(self.bounds)

    guard context != nil else {
        free(bitmapData)
        return nil
    }
    return context

}()

此处，变量Var a="myObject"; var b=a;是实例，变量a是参考

Answer 8

'instance'和'reference。'的实际英语语言定义。

实例：某个例子或单个事件。

参考：提及的行动。

因此，考虑到实际单词的这两个定义并将其应用于JavaScript场景，您可以理解每个概念的适用性。

javascript中引用和实例之间的区别

8 个答案: