在 Ethereum Solidity 中，“memory”关键字的作用是什么？

Question

When looking at sample contracts, sometimes arrays are declared in methods with "memory" and sometimes they aren't. What's the difference?

Answer 1

Without the memory keyword, Solidity tries to declare variables in storage .

Lead Solidity dev chriseth: “You can think of storage as a large array that has a virtual structure… a structure you cannot change at runtime - it is determined by the state variables in your contract”.

That is, the structure of storage is set in stone at the time of contract creation based on your contract-level variable declarations and cannot be changed by future method calls. BUT -- the contents of that storage can be changed with sendTransaction calls. Such calls change “state” which is why contract-level variables are called “state variables”. So a variable uint8 storagevar; declared at the contract level can be changed to any valid value of uint8 (0-255) but that “slot” for a value of type uint8 will always be there.

If you declare variables in functions without the memory keyword, then solidity will try to use the storage structure, which currently compiles, but can produce unexpected results. memory tells solidity to create a chunk of space for the variable at method runtime, guaranteeing its size and structure for future use in that method.

memory cannot be used at the contract level. Only in methods.

See the the entry "What is the memory keyword? What does it do?" in the FAQ. I quote it here:

The Ethereum Virtual Machine has three areas where it can store items.

The first is “storage”, where all the contract state variables reside. Every contract has its own storage and it is persistent between function calls and quite expensive to use.

The second is “memory”, this is used to hold temporary values. It is erased between (external) function calls and is cheaper to use.

The third one is the stack, which is used to hold small local variables. It is almost free to use, but can only hold a limited amount of values.

For almost all types, you cannot specify where they should be stored, because they are copied everytime they are used.

The types where the so-called storage location is important are structs and arrays. If you eg pass such variables in function calls, their data is not copied if it can stay in memory or stay in storage. This means that you can modify their content in the called function and these modifications will still be visible in the caller.

There are defaults for the storage location depending on which type of variable it concerns:

• state variables are always in storage
• function arguments are always in memory
• local variables of struct, array or mapping type reference storage by default
• local variables of value type (ie neither array, nor struct nor mapping) are stored in the stack

Answer 2

memory defines one of the data location in Solidity that can holds the value temporary only during the runtime.
the memory variables in Solidity can only be declared within the methods and usually used in method parameters. a short term variable that cannot be saved in blockchain... that holds the value only during the execution of a function and its value destroys after execution.

take a look at example function f() in which I declared a pointer using memory keyword.. it will not alter the value of variable User , whereas if it was declared using storage it will change the value of variable User stored in blockchain and value will not be destroyed...

struct User {
 string name;
}
User[] users;

function f() external {
 User memory user = users[0]; // create a pointer
 user.name = "example name" // can't change the value of struct User
}

Answer 3

When people talk about Storage and Memory in Solidity, they can actually be referring to two different uses of these words . And this causes a lot of confusion.

The two uses are:

1. Where a Solidity contract store data
2. How Solidity variables store values

Examples of each:

1. Where a Solidity contract store data: As Yilmaz correctly points out, in the first usage storage and memory can be thought of as similar to a hard drive (long-term, persistent storage) and RAM (temporary) respectively.

For example:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

contract StorageMemory1{
    uint storageVariable;

    constructor() {
    }

    function assignToValue(uint memoryVariable) public {
        storageVariable = memoryVariable;
    }
}

In the example above the value of 'storageVariable' will be saved even as we execute different functions over time . However, 'memoryVariable' is created when the 'assignToValue' function is called and then disappears forever after the function is complete.

2. How Solidity variables store values: If you see an error that says something like 'Data location must be "storage", "memory" or "calldata" for variable, but none was given.' then this is what it is referring to. This is best understood using an example.

For example:

You would get the above error with the following code:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

contract StorageMemory2 {
    uint[] public values;

    function doSomething() public
    {
        values.push(5);
        values.push(10);

        uint[] newArray = values; // The error will show here
    }
}

But if you add the word 'memory':

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

import 'hardhat/console.sol'; // to use console.log

contract StorageMemory2 {
    uint[] public values;

    function doSomething() public
    {
        values.push(5);
        values.push(10);

        console.log(values[0]); // it will log: 5

        uint[] storage newArray = values; // 'newArray' references/points to 'values'

        newArray[0] = 8888;

        console.log(values[0]); // it will log: 8888
        console.log(newArray[0]); // it will also log: 8888
    }
}

Notice what adding the word 'storage' does: it makes the 'newArray' variable reference (or point to) the 'values' variable, and modifying 'newArray' also modifies 'values' .

However, if we instead use 'memory' , notice what gets logged:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

import 'hardhat/console.sol'; // to use console.log

contract StorageMemory2 {
    uint[] public values;

    function doSomething() public
    {
        values.push(5);
        values.push(10);

        console.log(values[0]); // it will log: 5

        uint[] memory newArray = values; // 'newArray' is a separate copy of 'values'

        newArray[0] = 8888;

        console.log(values[0]); // it will log: 5
        console.log(newArray[0]); // it will log: 8888
    }
}

Using memory creates a copy variable, which does not reference the 'values' array.

And in case you are interested, ' calldata ' can be used to pass a variable as read-only:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.9;

contract CallDataExample {
    uint[] public values;

    function doSomething() public
    {
        values.push(5);
        values.push(10);

        modifyArray(values);
    }

    function modifyArray(uint[] calldata arrayToModify) pure private {
        arrayToModify[0] = 8888; // you will get an error saying the array is read only
    }
}

Answer 4

• Storage holds data between function calls. it is llike computer hard drive. variables are storage data

• Memory temporary place to store data, like RAM. Function args are memory data

Let s say one array is a storage type

// state variables are placed in Storage
int[] public numbers

function Numbers()public{
    numbers.push(5)
    numbers.push(10)
    int[] storage myArray=numbers
    // numbers[0] will also be changed to 1
    myArray[0]=1 
}

int[] storage myArray=numbers in this case myArray will point to the same address as "numbers". (it is similar to how referencing objects behave in javascript). See in the function I added 5, then 10 to "numbers" which is placed into Storage. But if you deploy the code on remix and get numbers[0] , you will get 1 because of myArray[0]=1

if you define myArray as memory it will be a different story.

// state variables are placed in Storage
int[] public numbers

function Numbers() public{
    numbers.push(5)
    numbers.push(10)
    int[] memory myArray=numbers
    myArray[0]=1 
}

In this case, "numbers" array is copied into Memory, and myArray now references a memory address which different from "numbers" address. if you deploy this code and reach numbers[0] you will get 5.