blocks|key|376018|text|这个问题可能会有帮助：How+to+pass+variable+by+reference+in+javascript?+Read+data+from+ActiveX+function+which+returns+more+than+one+value|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|376019|总而言之，Javascript原语类型总是通过值传递，而对象内部的值是通过引用传递的(感谢评论者指出我的疏忽)。所以要解决这个问题，你必须把你的整数放在一个对象中：|376020|var+myobj+=+{x:0};

function+a(obj)
{
++++obj.x%2B%2B;
}

a(myobj);
alert(myobj.x);+//+returns+1|code-block|syntax|javascript|376021|​|376022|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1732557/how-to-pass-variable-by-reference-in-javascript-read-data-from-activex-function^0|B|36|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

This question may help:
<a href="https://stackoverflow.com/questions/1732557/how-to-pass-variable-by-reference-in-javascript-read-data-from-activex-function">How to pass variable by reference in javascript? Read data from ActiveX function which returns more than one value</a>

To summarise, Javascript primitive types are always passed by value, whereas the values inside objects are passed by reference (thanks to commenters for pointing out my oversight). So to get round this, you have to put your integer inside an object:
 <div class="snippet" data-lang="js" data-hide="false" data-console="false" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var myobj = {x:0};

function a(obj)
{
 obj.x++;
}

a(myobj);
alert(myobj.x); // returns 1

 </code></pre>
</div>
</div>

blocks|key|376161|text|我发现了一种稍微不同的实现指针的方式，从C的角度来看，它可能更通用，更容易理解(因此更适合用户示例的格式)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|376162|在JavaScript中，就像在C中一样，数组变量实际上只是指向数组的指针，所以您可以使用与声明指针完全相同的数组。这样，无论您在原始对象中如何命名变量，代码中的所有指针都可以以相同的方式使用。|376163|它还允许使用两种不同的符号来表示指针的地址和指针地址处的内容。|376164|下面是一个例子(我用下划线表示一个指针)：|376165|var+_x+=+[+10+];

function+foo(_a){
++++_a[0]+%2B=+10;
}

foo(_x);

console.log(_x[0]);|code-block|syntax|javascript|376166|收益率|376167|output:+20|376168|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I have found a slightly different way implement pointers that is perhaps more general and easier to understand from a C perspective (and thus fits more into the format of the users example). 

In JavaScript, like in C, array variables are actually just pointers to the array, so you can use an array as exactly the same as declaring a pointer. This way, all pointers in your code can be used the same way, despite what you named the variable in the original object.

It also allows one to use two different notations referring to the address of the pointer and what is at the address of the pointer.

Here is an example (I use the underscore to denote a pointer):

<pre><code>var _x = [ 10 ];

function foo(_a){
 _a[0] += 10;
}

foo(_x);

console.log(_x[0]);
</code></pre>

Yields

<pre><code>output: 20
</code></pre>

blocks|key|376194|text|从window对象引用'x‘|type|unstyled|depth|inlineStyleRanges|entityRanges|data|376195|var+x+=+0;

function+a(key,+ref)+{
++++ref+=+ref+%7C%7C+window;++//+object+reference+-+default+window
++++ref[key]%2B%2B;
}

a('x');+++++++++++++++++++//+string
alert(x);|code-block|syntax|javascript|376196|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You refer to 'x' from window object

<pre><code>var x = 0;

function a(key, ref) {
 ref = ref || window; // object reference - default window
 ref[key]++;
}

a('x'); // string
alert(x);
</code></pre>

blocks|key|592061|text|回答晚了，但我遇到了一种通过闭包的方式通过引用来传递原始值的方法。创建一个指针是相当复杂的，但它是有效的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|592062|function+ptr(get,+set)+{
++++return+{+get:+get,+set:+set+};
}

function+helloWorld(namePtr)+{
++++console.log(namePtr.get());
++++namePtr.set('jack');
++++console.log(namePtr.get())
}

var+myName+=+'joe';
var+myNamePtr+=+ptr(
++++function+()+{+return+myName;+},
++++function+(value)+{+myName+=+value;+}
);

helloWorld(myNamePtr);+//+joe,+jack
console.log(myName);+//+jack|code-block|syntax|javascript|592063|在ES6中，代码可以缩短为使用lambda表达式：|592064|var+myName+=+'joe';
var+myNamePtr+=+ptr(=>+myName,+v+=>+myName+=+v);

helloWorld(myNamePtr);+//+joe,+jack
console.log(myName);+//+jack|592065|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Late answer but I have come across a way of passing primitive values by reference by means of closures. It is rather complicated to create a pointer, but it works.

<pre><code>function ptr(get, set) {
 return { get: get, set: set };
}

function helloWorld(namePtr) {
 console.log(namePtr.get());
 namePtr.set('jack');
 console.log(namePtr.get())
}

var myName = 'joe';
var myNamePtr = ptr(
 function () { return myName; },
 function (value) { myName = value; }
);

helloWorld(myNamePtr); // joe, jack
console.log(myName); // jack
</code></pre>

In ES6, the code can be shortened to use lambda expressions:

<pre><code>var myName = 'joe';
var myNamePtr = ptr(=&gt; myName, v =&gt; myName = v);

helloWorld(myNamePtr); // joe, jack
console.log(myName); // jack
</code></pre>

blocks|key|376292|text|Javascript应该只是把指针放在其中，因为它解决了很多问题。这意味着代码可以引用未知的变量名或动态创建的变量。它还使得模块化编码和注入变得容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|376293|在我看来，这是实践中最接近c%2B%2B指针的地方。|376294|在js中：|376295|var+a+=+78;+++++++//+creates+a+var+with+integer+value+of+78+
var+pointer+=+'a'+//+note+it+is+a+string+representation+of+the+var+name
eval+(pointer+%2B+'+=+12');+//+equivalent+to:+eval+('a+=+12');+but+changes+value+of+a+to+12|code-block|syntax|javascript|376296|在c中：|376297|int+a+=+78;+++++++//+creates+a+var+with+integer+value+of+78+
int+pointer+=+&a;+//+makes+pointer++to+refer+to+the+same+address+mem+as+a
*pointer+=+12;+++//+changes+the+value+of+a+to+12|376298|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Javascript should just put pointers into the mix coz it solves a lot of problems. It means code can refer to an unknown variable name or variables that were created dynamically. It also makes modular coding and injection easy.

This is what i see as the closest you can come to c pointers in practice 

in js:

<pre><code>var a = 78; // creates a var with integer value of 78 
var pointer = 'a' // note it is a string representation of the var name
eval (pointer + ' = 12'); // equivalent to: eval ('a = 12'); but changes value of a to 12
</code></pre>

in c:

<pre><code>int a = 78; // creates a var with integer value of 78 
int pointer = &amp;a; // makes pointer to refer to the same address mem as a
*pointer = 12; // changes the value of a to 12
</code></pre>

blocks|key|376047|text|在JavaScript中，这将是一个全局的。但是，您的函数看起来更像这样：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|376048|function+a(){
+++x%2B%2B;
};|code-block|syntax|javascript|376049|由于x位于全局上下文中，因此不需要将其传递给函数。|offset|length|style|CODE|376050|entityMap^0|0|0|2|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

In JavaScript that would be a global. However, your function would look more like this:

<pre><code>function a(){
 x++;
};
</code></pre>

Since <code>x</code> is in the global context, you don't need to pass it into the function.

blocks|key|592250|text|这可能是不可能的，因为JavaScript没有Perl的"\“操作符来通过引用获取原语，但是有一种方法可以使用这种模式为原语创建一个”有效的指针“对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|592251|这种解决方案在以下情况下最有意义:您已经拥有了原语(因此您不需要修改其他代码就可以将其放入对象中)，但仍然需要传递指向它的指针，以便代码的其他部分修补它的状态；因此，您仍然可以使用行为类似于指针的无缝代理来修补它的状态。|592252|var+proxyContainer+=+{};

//+%7C+attaches+a+pointer-lookalike+getter/setter+pair
//+%7C+to+the+container+object.
var+connect+=+function(container)+{
++++//+%7C+primitive,+can't+create+a+reference+to+it+anymore
++++var+cant_touch_this+=+1337;

++++//+%7C+we+know+where+to+bind+our+accessor/mutator
++++//+%7C+so+we+can+bind+the+pair+to+effectively+behave
++++//+%7C+like+a+pointer+in+most+common+use+cases.
++++Object.defineProperty(container,+'cant_touch_this',+{
++++++++'get':+function()+{
++++++++++++return+cant_touch_this;
++++++++},++++++++++++++++
++++++++'set':+function(val)+{
++++++++++++cant_touch_this+=+val;
++++++++}
++++});
};

//+%7C+not+quite+direct,+but+still+"touchable"
var+f+=+function(x)+{
++++x.cant_touch_this+%2B=+1;
};

connect(proxyContainer);

//+%7C+looks+like+we're+just+getting+cant_touch_this
//+%7C+but+we're+actually+calling+the+accessor.
console.log(proxyContainer.cant_touch_this);

//+%7C+looks+like+we're+touching+cant_touch_this
//+%7C+but+we're+actually+calling+the+mutator.
proxyContainer.cant_touch_this+=+90;

//+%7C+looks+like+we+touched+cant_touch_this
//+%7C+but+we+actually+called+a+mutator+which+touched+it+for+us.
console.log(proxyContainer.cant_touch_this);

f(proxyContainer);

//+%7C+we+kinda+did+it!+:)
console.log(proxyContainer.cant_touch_this);|code-block|syntax|javascript|592253|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

It might be impossible since JavaScript doesn't have Perl's "\" operator to get a primitive by reference, but there is a way to create an "effectively a pointer" object for a primitive using this pattern.

This solution makes the most sense for when you already have the primitive(so you can't put it into an object anymore without needing to modify other code), but still need to pass a pointer to it for other parts of your code to tinker with its state; so you can still tinker with its state using the seamless proxy which behaves like a pointer.

<pre><code>var proxyContainer = {};

// | attaches a pointer-lookalike getter/setter pair
// | to the container object.
var connect = function(container) {
 // | primitive, can't create a reference to it anymore
 var cant_touch_this = 1337;

 // | we know where to bind our accessor/mutator
 // | so we can bind the pair to effectively behave
 // | like a pointer in most common use cases.
 Object.defineProperty(container, 'cant_touch_this', {
 'get': function() {
 return cant_touch_this;
 }, 
 'set': function(val) {
 cant_touch_this = val;
 }
 });
};

// | not quite direct, but still "touchable"
var f = function(x) {
 x.cant_touch_this += 1;
};

connect(proxyContainer);

// | looks like we're just getting cant_touch_this
// | but we're actually calling the accessor.
console.log(proxyContainer.cant_touch_this);

// | looks like we're touching cant_touch_this
// | but we're actually calling the mutator.
proxyContainer.cant_touch_this = 90;

// | looks like we touched cant_touch_this
// | but we actually called a mutator which touched it for us.
console.log(proxyContainer.cant_touch_this);

f(proxyContainer);

// | we kinda did it! :)
console.log(proxyContainer.cant_touch_this);
</code></pre>

blocks|key|591899|text|在JavaScript中，不能通过引用将变量传递给函数。但是，您可以通过引用传递对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|591900|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In JavaScript, you cannot pass variables by reference to a function. However you can pass an object by reference.

blocks|key|592166|text|JavaScript不支持通过引用传递基元类型。不过，还是有一个变通办法的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|592167|将需要传递的所有变量放入一个对象中。在本例中，只有一个变量，即x。将变量名作为字符串传递，而不是传递变量，字符串为"x"。|offset|length|style|CODE|592168|​|592169|var+variables+=+{x:0};
function+a(x)
{
++++variables[x]%2B%2B;
}
a("x");
alert(variables.x);|code-block|syntax|javascript|592170|592171|entityMap^0|0|V|1|1L|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]|$D|V|E|W|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|Y|8|@]|9|@]|A|$M|N]]|$1|O|3|I|5|6|7|Z|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|Q|$]]

JavaScript doesn't support passing primitive types by reference. There is a workaround, though.

Put all the variables you need to pass in an object. In this case, there's only one variable, <code>x</code>. Instead of passing the variable, pass the variable name as a string, which is <code>"x"</code>.

<div class="snippet" data-lang="js" data-hide="false" data-console="true">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var variables = {x:0};
function a(x)
{
 variables[x]++;
}
a("x");
alert(variables.x);</code></pre>
</div>
</div>

blocks|key|376469|text|根据您想要做的事情，您可以简单地保存变量名，然后在以后访问它，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|376470|function+toAccessMyVariable(variableName){
++alert(window[variableName]);
}

var+myFavoriteNumber+=+6;+

toAccessMyVariable("myFavoriteNumber");|code-block|syntax|javascript|376471|要应用于您的特定示例，您可以这样做：|376472|var+x+=+0;
var+pointerToX+=+"x";

function+a(variableName)
{
++++window[variableName]%2B%2B;
}
a(pointerToX);
alert(x);+//Here+I+want+to+have+1+instead+of+0|376473|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Depending on what you would like to do, you could simply save the variable name, and then access it later on like so:

<pre><code>function toAccessMyVariable(variableName){
 alert(window[variableName]);
}

var myFavoriteNumber = 6; 

toAccessMyVariable("myFavoriteNumber");
</code></pre>

To apply to your specific example, you could do something like this: 

<pre><code>var x = 0;
var pointerToX = "x";

function a(variableName)
{
 window[variableName]++;
}
a(pointerToX);
alert(x); //Here I want to have 1 instead of 0
</code></pre>

blocks|key|376524|text|它只是不支持指针，故事的结尾:-(。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|376525|我想补充的是，虽然我是一个全新的C背景，但从我读到的关于事件循环和堆栈的内容来看，你应该让任何一个对象尽可能靠近它的调用者。由于我是全新的，我可能会弄错。|376526|这里的许多答案都建议将其设置为全局的，但如果我没看错的话，这可能会增加堆栈跳数，并且在某种程度上，可能会不必要地分割事件循环(这取决于被调用的对象当前正在做什么)。|376527|此外，任何给定的模仿指针的例子，在许多方面都只是做同样的事情的1，这将不是指针。|376528|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

It just doesn't support pointers, end of story :-(.

I would like to add that, while I'm brand new and coming from a C background, from what I'm reading about the event loop and stack, you should keep whichever object as close to its caller as possible. As I'm brand new, I could have this wrong. 

A lot of answers here suggest to make it global, but again if I'm reading correctly, that could possibly increase the stack hops and in a way, possibly fragment your event loop needlessly (depending on what the called object is currently doing) .

Also, any example given that mimics pointers, is just 1 in many ways to do the same thing, which will not be a pointer.

blocks|key|592412|text|我同意引号最多的答案，但请从'var‘参数中注意，使用'let'，或者在本例中使用'const’更好，因为指针或指向对象不应该在任何时候改变。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|592413|const+x+=+{value:+0};

function+foo(obj){
++%2B%2Bobj.value;
}

foo(x);
alert(x.value);|code-block|syntax|javascript|592414|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I'll agree with the most quotet answer, but please be aware from 'var' argument, use 'let', or better in this case 'const', because the pointer, or the pointing object shouldn`t be change anytime.
<pre><code>const x = {value: 0};

function foo(obj){
 ++obj.value;
}

foo(x);
alert(x.value);
</code></pre>

Can we pass a reference of a variable that is immutable as argument in a function?

Example:

<pre><code>var x = 0;
function a(x)
{
 x++;
}
a(x);
alert(x); //Here I want to have 1 instead of 0
</code></pre>

Pointers in JavaScript?

Perl

我们可以在函数中传递一个不可变变量的引用作为参数吗？示例：var x = 0;function a(x){    x++;}a(x);alert(x); //Here I want to have 1 instead of 0

问JavaScript中的指针？
EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript中的指针？EN

回答 12

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript中的指针？
EN