可变大小的JavaScript字符串如何是原始类型？

Question

From what I understand, the (basic) string type in JavaScript is a primitive type, meaning its variables are allocated on the stack.

I would have thought that for a type to be allocatable on the stack, it needed to have a fixed size -- something which presumably holds true for the other primitive types like boolean , number , etc.

Am I somehow wrong to assume that, or is some other internal magic used to make string s in JavaScript primitive types?

---

EDIT: This gets more complicated when one considers that JavaScript is loosely typed. Which makes me wonder how any local variable can be allocated on the stack.... given that the size of what might be assigned to it during the course of a function is not fixed.

But I guess (a perhaps simplified) answer to this might be that all local variables could be assigned a fixed maximum size on the stack. Say this is 8 bytes which I think is the size of the number type, and should be large enough to accommodate all the other primitive types (except the string ) as well as memory addresses (for when a local variable is assigned a reference type). But, surely strings cannot be limited to 8 bytes (or any size for that matter). Which makes me conclude that strings (even the primitive type ones) are not (cannot be) assigned on the stack. And hence the term "Primitive type" in JavaScript is used to mean a "basic/building block" type, rather than one which is necessarily allocated on the stack (contradicting what I have read in numerous sources including the book "Professional JavaScript..." by Nicholas Zakas).

Anyone have any other take or a pointer to a good source talking about this?

Answer 1

A string is a both an object and a primitive.

When doing:

var s = "this is a string";

you actually do:

var s = new string("this is a string");

behind the curtains.

The first being a primitive array with characters, on which the second one refers.

Strings are immutable, meaning they can't be changed. If you try to change it (ie reverse it), you will create a new string primitive, on which the object reference will point to.

Answer 2

用于在Javascript解释器中表示变量的存储不必看起来像堆栈-它取决于实现。

Answer 3

1. Strings aren't allocated on the stack
2. where a variable is allocated doesn't distinguish primitives from objects
3. Strings aren't primitives, they are of the class "string"

The difference between a primitive and a type is that types have methods and you can assign new properties to them:

var a = 1, b = {}, s = '';
a.foo = 1; // doesn't work, but no error either
b.foo = 1; // works
s.foo = 1; // doesn't work, but no error either

console.log(a.foo);
console.log(b.foo);
console.log(s.foo);
​

gives

undefined
1
undefined

So all in all, I'm not sure that using "primitive" makes sense in JavaScript since the line is blurred.

A string is a "value object" which means you can't change any of the properties. For example, when you replace characters in a string, you get a new string; the old string doesn't change.