Creating Dynamic Arrays of Persons in Solidity

Creating a dynamic array of persons streamlines managing favorite numbers and names in Solidity.

### Creating and Managing Dynamic Arrays of Custom Types in Solidity
* 💻 To enhance the management of friends' data, we shift from using individual variables to creating a **dynamic array of custom types**, specifically a struct called `person`.
* 📝 The struct `person` includes a `uint256` for a **favorite number** and a `string` for the **name**, allowing us to store more organized information about each individual.
* 🔧 A public function, `add person`, is introduced to facilitate adding new entries to the array, utilizing the built-in **`push` method for dynamic arrays**.
* 📊 When we add a person, such as "Patrick" with a favorite number of 7, the array updates to reflect this new entry, demonstrating how the **dynamic array grows**.
* 🔍 The array is zero-indexed, meaning the **first entry is accessed at index 0**, and we can continue adding more individuals, such as "John" with a favorite number of **16**.
* ⚙ By creating a variable of type `person`, we can easily instantiate new entries, ensuring that **each person's data is structured and easily accessible**.
* 📈 The public visibility of the array allows us to **retrieve specific entries by their index**, although initially, the array starts **empty** until we add our first entries.
* 🎉 This structured approach not only **simplifies the code** but also sets the foundation for **managing potentially large lists of friends and their favorite numbers efficiently**.

now our contract as is is pretty good. It does one thing pretty well. It allows us to store our favorite number, update that favorite number, and then view that favorite number. And in fact, let's go ahead and make this an internal variable, and we'll have the retrieve function be the way to get this. We can have this public, but for now, we're going to set it up like this, and I'll tell you why we're going to set it up like that in the future. But what if we wanted to be able to store not just our favorite number, but other people's favorite numbers as well? Well, what we could do is we could create something called an array or a list of favorite numbers. What we could do is we could say, instead of just one unit256, we could have a list of uint256 called list of favorite numbers. This bracket syntax here identifies that we have a list of uint256 or a list of numbers or an array of numbers. An array of numbers is going to look something like this. It's going to have B maybe the

first element is going to be zero. Maybe the second favorite number is going to be 78. The third favorite number is going to be 90. Now arrays are very common in computer science and programming, and an array in Solidity is exactly the same as an array in any other programming language. If you're unfamiliar with arrays or lists, they are actually zero-indexed, so the zero here is actually at index 0. So, we refer to this object here as the zeroth object, right? This could be 77, and this would be the zeroth object. The 78 is going to be the first element, the 90 is going to be the second element, and so on and so forth. It's very common in computer science to actually start counting from the number zero, and arrays start counting from the number zero. We'll learn to play around with arrays more in just a minute. So, this list of favorite numbers is great, but how do we know whose favorite number each section is? If this is our list of favorite numbers, how do we know who 0 is, whose 78?

is who 90 is ETC well maybe what we would do instead of just having a raw list like this. Let's go ahead and comment this line out. Maybe we could create a new type called a person in solidity. You can actually create your own types using the struct keyword. So, we're going to say struct person and do little curly brackets like this. Inside of these curly brackets, we can define what this struct person custom type is comprised of. And we're going to say for every person, they're going to have a u and 256 favorite number and a string name. Now, something important to note is oh whoops we have two favorite numbers here. Remember what we learned about scope. Since this favorite number is inside of these curly brackets, these would clash a little bit. So, what we're going to do instead is we're going to rename favorite number up here to my favorite number. And we're going to copy paste that down here as well. So, we're renaming this state variable, this storage variable to my favorite number and just keeping it down here that way.

We can have a favorite number inside of this struct in any case. We created this new type of type person, which is a combination of each person has a favorite number, and each person also has a name. Now, similar to how we can have a unit 256, a Boolean, a string, and n256, etc., we now have a type of person, and this is similar to each one of these. Oh, and we're also going to have to update the retrieve down here with my favorite number instead of favorite number. Now, since we have our own new type, we can actually create a variable of type person the exact same way we created a variable of type my favorite number. So, we could say person visibility will be public my friend equals, and we'll put person here and put some parentheses here because when you're working with custom types, you have to define both on the left side and on the right side what type it is. And in here, we would assign a favorite number and a name. So, we could say seven and hatch like that. So, now Pat is going to be a person with a favorite

number of seven and a name of Pat. See, the first parameter goes to the first item in the person's struct, and the second parameter goes to the second item. I like being a little bit more explicit when working with structs, and actually what you can do is you can put little brackets here instead, and you could say exactly what value you're going to assign to what section. So, I can say favorite number is going to be 7, and name is going to be Pat. And we hit command S or just go straight to compile to see if it worked correctly, get that little green check mark. Now, by doing this, we've created our own type person, and we've created a variable named Pat with a favorite number of seven and a name of Pat. Now, if we were to go ahead, let's delete this old simple storage, and let's deploy our new simple storage, and we scroll down, we now have a new blue button since this is a public variable called Pat. And if we click the button, if we call this variable, we'll see favorite

number of 7 and string name Pat. You can also see this 0 in this one, which shows the index of each one of these variables or parameters. 0 is for favorite number, 1 is for name. If we added another one, maybe Bool is cool, full is cool, would be at index 2. Whenever we create a custom type like this, Solidity will automatically index them, similar to the way that we index our lists or our arrays: favorite number 0, name 1, whatever this next would be 2, etc. Now, this is great for one friend, but what if you have a lot of friends, which I know a lot of you do because you're taking this course, which automatically means you're cool. Maybe what if you have your friend Mariah that you would like to add to our smart contract like this, and her favorite number is 16. Or maybe your friend John. You'd have to copy-paste the line, add John in here, his favorite number is going to be 12, so on and so forth. It might get very tedious to have to write variables for all of these.

people for all these friends. This obviously isn't a great way for us to create lists of people or lists of our friends. So instead of this, we can actually use this array syntax that we just learned and create an array of persons or a list of persons. So I'm going to comment all these out for now, and a quick tip here: if you're on a Mac and you highlight a couple, if you're on a Mac and you hit command backslash or command question mark, it'll automatically comment or uncomment those lines. If you're on a Windows, I believe it is control slash, but you might be able to Google what the actual keyboard shortcut is. This is a keyboard shortcut I use all the time. So what we're going to do now is we're going to create a list or an array of persons. So exact same as we did it up here, we'll say our type first is going to be type person array. So we're up type person array. Then we'll state our visibility, which is going to be public.

then we'll get our variable name, which is going to be a list of people, like this. So, we've created a person array with visibility public and the name list of people, and we'll just leave it blank for now, so it'll get defaulted to being an empty list, which would look like this. Now, if I were to go ahead and deploy this, let's delete the last one, let's compile, deploy, scroll down, we select this, we now see we have our retrieve blue button, and we also have this blue button for list of people. When you create arrays with a public keyword, instead of being able to see the whole array with this list of people button, you actually have to put in the index of the element you want to work with, and you get to see that exact element. It wants to take a u and 256 as an input parameter. However, obviously, our array is blank, so if we say, What is the person at the zeroth index? It'll say, Well, nothing, because you have a blank array. Well, what about the first index? Well, nothing. What

about the second one, well, nothing. No matter what you put in the box right now, it's going to return nothing. We'll show you how to add to this array in just a second. This kind of array is known as a dynamic array because the size of the array can actually grow and shrink. In Solidity, a dynamic array is signified by what's inside of these little brackets here. If we added a 3 in here, this would be a static array. We're saying this list of people can only have a maximum size of three, so we can only put three persons in this array. Dynamic array, static array can have any size, can only go up to three, any size up to three, any size up to four. Hopefully, you get the picture. We're going to work with a dynamic array because we're going to want to add an arbitrary number of people to this person array. So let's create a function that will allow us to actually add people and update this array, and let's delete this comment. So below our retrieve function, we'll create a

function add person, and this is going to take two variables as input. It's going to take the name of the person that we're going to add. It's going to take the favorite number of the person that we're going to add, as well as the name. So, we'll say string memory name, and I'll explain this memory keyword in a little bit. And we'll do U into 256 underscore favorite number. And let's do and let's do underscore name. And we'll make this a public function. And what we're going to do inside of this add person function is we're going to take this list of people object and call the push function on it. Arrays come built in with a function called push, which allows us to add elements or add person to our list of people array. So, what we're going to do is we're going to say list of people.push, and we'll add these little parentheses here. And we're going to push a new person onto this array. Now, what we could do now, let's comment this out for now. Now, what

we could do is we could create a new person. New person equals person name, favorite number, like we did above. Oops, excuse me, these are backwards. Person memory, new person, which we're going to ignore that for now. And then just to list of people.push new person. We could do this. This is valid syntax, and I'll explain this memory keyword in a little bit. This is going to create a new person, and we push the list. Or we could just add this person right into this push piece here. So we could delete this line. Instead of creating a new person on its own line, we could say list of people.push person. Then we'll add in here favorite number, name, since we're calling this person favorite number, name, inside of this push object. Solidity is smart enough to execute this line of code first, create a new person, and then execute this line to push our person into this list of people object. So this function should allow us to push new people into our list of people array. So what we can do now is let's compile this, let's deploy this.

let's delete the old one. We'll hit deploy now. We see if we call our list of people at zero. We'll get nothing back because it starts off as a blank array. But now we have this new add person function where we can, you can kind of see very faintly, it takes a string name and a u and 256 a favorite number. So we can add Patrick seven. We'll hit add person, which if you have your terminal, you'll see we made a transaction. And now if we hit list of people at zero, we see we have a deed added a person to the zero with index asterisk has a favorite number of seven. And his name is Patrick. Obviously, if we hit one, we'll get nothing back. And this will just stay up. But if we add another person, maybe John 16, add person now at list of people index one. We now see John 16. So zero is going to be Patrick seven, one John 16, two is nothing. So nothing happens.

Lesson 2 Part 5 | Arrays & Structs - Solidity & Foundry Full Course

Book a smart contract audit here 👇
https://www.cyfrin.io/


Cyfrin Audits

The contract currently allows for storing, updating, and viewing a single favorite number.

To accommodate multiple favorite numbers, an array of uint256 is proposed, with each element representing a different favorite number.

Arrays are zero-indexed, meaning the first element is at index 0, and the contract will need a way to associate each favorite number with the person it belongs to.

Creating a Custom Person Type in Solidity

A new type called "person" is created, combining a favorite number and a name.

Variables of this custom type can be instantiated similarly to built-in types.

The code allows for pushing new person instances into a list, with Solidity executing the creation and addition in a single line.

A custom type called "person" is created using the struct keyword, with a favorite number (uint256) and a name (string) as its properties.

The favorite number variable is renamed to "my favorite number" to avoid scope clashes.

A dynamic array is used to store an arbitrary number of persons, with the option to create a static array for a maximum size.

An array syntax is used to create a list of persons, replacing the previous method.

The list of people starts off as a blank array and can be populated using an "add person" function.

The function takes a person's name and favorite number as input and uses the push method to add the person to the array.

A public array for storing a list of people is created, defaulting to an empty list.

To access elements, the index must be provided, as the public keyword prevents viewing the whole array.

Custom types are automatically indexed by Solidity, making it easier to manage multiple friends in the smart contract.