Data Location Assignment

[jon_m]

Hi @KennethJP,

@KennethJP

I believe there is a simpler way to do this

Yes there is… In fact you can remove your 2nd and 3rd lines in the updateBalance function, and your 1st line on its own will still produce the same result…

function updateBalance(uint id, uint newBalance) public {
    users[id] = User(id, newBalance);
}

But this makes the updateBalance function exactly the same as the addUser function.
While this does still work…

@jon_m

If we have two functions that perform exactly the same operation, that’s not efficient, and so in this case we might as well remove one of the functions and just call the remaining one something more general, such as update().

However, this is hardly ideal. So what you want to aim for with the updateBalance function, is code that only updates the balance property for a particular user ID, and not the whole User instance. We only need to create a whole new User instance when we add a new user, because once added, their user ID won’t need to change (at least not at the same time as their balance).

So, instead of the 1st line of code in your solution, you can start with your 2nd line…

@KennethJP

User storage user = users[id];

@jon_m

By assigning users[id] to a local storage variable, we create a local “pointer” called user . This points to (references) the User instance in the mapping which is mapped to the id parameter input into the function. Any value assigned to this local “pointer” variable is effectively updating the instance stored persistently in the mapping.

The local variable user creates a temporary “bridge” to the mapping during execution of the function, so that the newBalance can be added to a specific user’s balance stored persistently in the mapping, before this “bridge” is lost when the function finishes executing.

So, you then want to assign newBalance to the balance property of the pointer you’ve just created, as follows:

user.balance = newBalance;

… and this will update the user’s balance in the mapping.

What you’ve done is re-assigned the balance property of the pointer itself to another local variable (which shouldn’t have the same name as your parameter newBalance, anyway).

@KennethJP

uint newBalance = user.balance;

Let me know if anything is unclear, or if you have any questions

[jon_m]

Nice solutions @DavidV

Apologies for the delay in answering your question…

@DavidV

my question however is that where does user[id] get assigned the values of _user? At moment its the other ay around. _user gets the value assigned to users[id].

I would think a line like : user[id].balance = _user.balance woud be needed.

---

Good question! … and, yes, this can be difficult to understand, at first.
The specific user’s instance in the mapping (users[id]) doesn’t need to be assigned the values stored in _user , because _user temporarily is that user’s instance in the mapping. Let me explain…

User storage user = users[id];

@jon_m

By assigning users[id] to a local storage variable, we create a local “pointer” called user . This points to (references) the User instance in the mapping which is mapped to the id parameter input into the function. Any value assigned to this local “pointer” variable is effectively updating the instance stored persistently in the mapping.

The local variable user creates a temporary “bridge” to the mapping during execution of the function, so that the amount ( balance ) can be added to a specific user’s balance stored persistently in the mapping, before this “bridge” is lost when the function finishes executing.

user.balance = balance;

Just let me know if anything is still unclear, or if you have any more questions

[jon_m]

Hi @Cero,

@Cero

Since You are just rewrite the balance and not transfering etc. the solution for updateBalance is the same as addUser with balance.

Technically, speaking, you are correct
However …

@jon_m

If we have two functions that perform exactly the same operation, that’s not efficient, and so in this case we might as well remove one of the functions and just call the remaining one something more general, such as update().

However, this is hardly ideal. So what you want to aim for with the updateBalance function, is code that only updates the balance property for a particular user ID, and not the whole User instance. We only need to create a whole new User instance when we add a new user, because once added, their user ID won’t need to change (at least not at the same time as their balance).

I assume you’ve already seen the 2 alternative solutions suggested in the follow-up video. Can you see how they are more suitable?

[jon_m]

Nice solution @FerfiC

@FerfiC

By referencing the id, we can access the user balance and update it to the value we want.

Yes… we use the id to reference that user’s instance in the mapping, where it is stored persistently. Then, as you say, we can access the balance property of that user’s instance, and update it with the new balance that has been input into the function.

[jon_m]

Hi @Denzel,

@Denzel

Just write the same function and it overwrites it.

Technically, speaking you are correct
However …

@jon_m

If we have two functions that perform exactly the same operation, that’s not efficient, and so in this case we might as well remove one of the functions and just call the remaining one something more general, such as update().

However, this is hardly ideal. So what you want to aim for with the updateBalance function, is code that only updates the balance property for a particular user ID, and not the whole User instance. We only need to create a whole new User instance when we add a new user, because once added, their user ID won’t need to change (at least not at the same time as their balance).

I assume you’ve already seen the 2 alternative solutions suggested in the follow-up video. Can you see how they are more suitable?

[Gos]

newBalance gets lost after function is done because it was in memory, now it is in storage and will be stored for ever on the blockchain.

    function updateBalance(uint id, uint balance) public{
         User storage user = users[id];
         user.balance = balance;  
    }

[Jacky_Li]

I didn’t create a new variable with a storage variable like I noticed many people did. I was under the assumption we can directly update the specified user, since we have access to the state variable ‘users’ and the ‘id’ as well. I checked and my way did work. If this is incorrect, would love to hear why we do need to create a storage variable!

contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function updateBalance(uint id, uint balance) public {
        uint oldBalance = users[id].balance;
         users[id].balance += balance;
         
         assert(users[id].balance == oldBalance + balance);
    }

    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }

}

[Pedro_GM]

Hey guys! At first, all I did was change “memory” to “storage” in the updateBalance function.

Then realized I could skip the step where we assign the user to a local variable. And this is my result:

pragma solidity 0.7.5;
contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function updateBalance(uint id, uint balance) public {
        users[id].balance = balance;
         
    }

    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }

}

[Filip_Rucka]

pragma solidity 0.7.5;
contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function updateBalance(uint id, uint balance) public {
         User storage user = users[id];
         user.balance = balance;
    }

    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }

}

[Cero]

Thank You for the explanation. I can see about the efficiency of the code. I also saw the solutions in video.

[Denzel]

Simpler than I imagined haha, thanks for the help

[GahuckImGoofy]

pragma solidity 0.7.5;
contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function updateBalance(uint id, uint balance) public {
         users[id].balance = balance;
    }

    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }

}

[jon_m]

Nice solution @Jacky_Li

… and welcome to the forum! I hope you’re enjoying the course

@Jacky_Li

I didn’t create a new variable with a storage variable like I noticed many people did.

Using a local storage variable to create a “pointer” to a specific User instance in the mapping, is just one alternative, and your solution is equally valid.

@Jacky_Li

I was under the assumption we can directly update the specified user, since we have access to the state variable ‘users’ and the ‘id’ as well.

That’s correct

@jon_m

Even though the initial idea of this assignment is to update the existing balance by replacing it with the new one, I actually think that it makes more sense to do what you have done, and add an amount to the existing balance using the addition assignment operator += (instead of the assignment operator = ). However, if you add to , instead of replacing , the existing balance, I think your code would be clearer and more readable if you also change the name of the balance parameter to amount , because you are adding an amount to the balance, rather than replacing it with a new balance .

Just let me know if you have any further questions

[jaejang22]

pragma solidity 0.7.5;
contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
     users[id] = User(id, balance);
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

[Carlo]

pragma solidity 0.7.5;

contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
     users[id].balance = balance;
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

[jon_m]

Welcome to the forum @jaejang22! It’s good to see you here, and I hope you’re enjoying the course

Your solution works, but your updateBalance function is now exactly the same as the addUser function.

@jon_m

If we have two functions that perform exactly the same operation, that’s not efficient, and so in this case we might as well remove one of the functions and just call the remaining one something more general, such as update().

However, this is hardly ideal. So what you want to aim for with the updateBalance function, is code that only updates the balance property for a particular user ID, and not the whole User instance. We only need to create a whole new User instance when we add a new user, because once added, their user ID won’t need to change (at least not at the same time as their balance).

I assume you’ve already seen the 2 alternative solutions suggested in the follow-up video. Can you see how they are more suitable?

[t3hmun]

Simple solution: change user var to storage or just access without creating local var.
I decided to overcomplicate with a function just so I can use a storage parameter as an excercise.

    function updateBalance(uint id, uint balance) public {
         User storage user = users[id];
         _updateBalance(user, balance);
    }
    
    function _updateBalance(User storage user, uint balance) private {
        user.balance = balance;
    }

[Jackthelad]

After a reasonably long time thinking about how stupid I must be to not understand why the extra user variable was needed, I eventually just messed around and removed it, solving the problem of the memory keyword creating a new local User value that would not persist outside the function.

function updateBalance(uint id, uint balance) public {
//remove loval variable 'user', instead accessing the balance via mapping.
         users[id].balance = balance;
    }

[Andre_Mark]

It was to do with mapping right? because before it was memory, which is a temporary location, and the mapping is located in storage, so they don’t connect, so you change it to; User storage user and they map?

[ZED91]

I just modified the updateBalance function, so the updated balance doesn’t just stay within the function. Changing from memory to storage does the job.

pragma solidity 0.7.5;
contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function updateBalance(uint id, uint balance) public {
         User storage user = users[id];
         user.balance = balance;
    }

    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }

}