Struct Array in Solidity: A Beginner Smart Contract Guide

The keyword struct lets you define a custom record type by listing its fields. Wrap that type in square brackets and you turn it into an array of records. So Student[] is a list of Student values, each one holding the same named fields in the same order.

The mental model is a row of folders. Each folder sits at a numbered position and contains the same set of named fields on the inside. To pull the third folder you write students[2]. To peek at one field on that folder you write students[2].score. Indexes still start at zero, and the length still grows by one on every push.

The contract needs three operations. Append a new student. Read any student by position. Know how many students are on the list. A struct array does all three with the smallest possible code surface, and it keeps the three fields glued together so a single index always gives you the full record.

Other places this same shape shows up: a product catalogue where each row carries a name, a price, and a stock count; a voter roll where each entry carries an address, a weight, and a registration time; a todo list where each task carries a description, a deadline, and a done flag. Whenever a row needs more than one field, reach for a struct array.

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

contract StudentRegistry {
    // 1. The struct definition. Every entry has these three fields.
    struct Student {
        string name;
        uint256 score;
        bool passed;
    }

    // 2. The storage array of student records.
    Student[] public students;

    // 3. Add a student. The passed flag is derived from the score.
    function addStudent(string memory name, uint256 score) external {
        students.push(Student({
            name: name,
            score: score,
            passed: score >= 50
        }));
    }

    // 4. Read one full student record by index.
    function getStudent(uint256 i) external view returns (Student memory) {
        require(i < students.length, "out of range");
        return students[i];
    }

    // 5. Return how many students are on the list.
    function totalStudents() external view returns (uint256) {
        return students.length;
    }
}

Paste this into Remix at remix.ethereum.org, compile with the 0.8.20 compiler, and deploy to the JavaScript VM. In the deploy panel call addStudent with values like ("Aisha", 85) and ("Bilal", 42). The public getter on students lets you read entries one at a time without writing any extra function.

struct Student {
    string name;
    uint256 score;
    bool passed;
}

The struct keyword introduces a custom record type. The fields are declared in order: a UTF-8 string, an unsigned integer, and a boolean. The compiler keeps the order, which matters when you construct a struct with positional arguments later.

Student[] public students;

The type Student[] declares a dynamic storage array where every slot holds a full Student record. The keyword public generates a getter that returns one record at a time. Solidity unpacks the fields for the auto generated getter, so a caller sees three return values rather than a single struct.

function addStudent(string memory name, uint256 score) external {
    students.push(Student({
        name: name,
        score: score,
        passed: score >= 50
    }));
}

The function constructs a new Student using named arguments and pushes it onto the array. Named arguments make the intent obvious and protect you from reordering the struct fields by accident. The passed flag is derived from the score so the caller only has to supply the inputs that are not derivable.

function getStudent(uint256 i) external view returns (Student memory) {
    require(i < students.length, "out of range");
    return students[i];
}

The return type is Student memory because the caller gets a fresh copy of the record, not a pointer into storage. The require guard rejects out of range indexes before the lookup runs. ABI encoding for the return takes care of packing the three fields into the response.

function totalStudents() external view returns (uint256) {
    return students.length;
}

The length is reported as a plain uint256 regardless of the element type. This pattern is the same across every Solidity array in this beginner series.

Adding data uses students.push(Student(...)). You can use positional arguments like Student("Aisha", 85, true) or named arguments like Student({ name: "Aisha", score: 85, passed: true }). Named is safer because reordering struct fields later does not silently break old call sites.

Reading data uses bracket lookup. The whole record at index one is students[1]. A single field on that record is students[1].score. Field access works because Solidity treats the bracket result as a storage reference when the array is in storage, which lets you read or write the field directly.

Counting items uses students.length. The result is a uint256 you can compare in a require, use as an index bound for the methods in Section 06, or return for off chain code to read.

Start with the StudentRegistry contract you already have. Each function below goes right after the existing ones inside the contract body. None of them needs a for loop, and each one teaches a distinct rule of Solidity struct storage.

Function 1. Remove the last student with pop

function dropLast() external {
    require(students.length > 0, "empty");
    students.pop();
}

students.pop() drops the last record and shrinks the length by one. The require guard is critical: calling pop on a zero length array triggers a panic and the transaction reverts. Add the guard whenever the array can be empty at call time.

Function 2. Reset one slot with delete by index

function clearStudent(uint256 i) external {
    require(i < students.length, "out of range");
    delete students[i];
}

delete students[i] resets every field on that slot to the type default in one line. The name becomes the empty string, the score becomes zero, and the passed flag becomes false. The array length does not change. If zero score or empty name is legal in your domain, mark cleared slots some other way, for example by adding a removed flag to the struct.

Function 3. Wipe the entire array with delete on the variable

function clearAll() external {
    delete students;
}

delete students on the whole array resets every slot to its struct default and sets the length back to zero in one line. After the call, every indexed read goes out of range, and the next push starts a fresh list from index zero.

Function 4. Update a single field with direct assignment

function updateScore(uint256 i, uint256 newScore) external {
    require(i < students.length, "out of range");
    students[i].score = newScore;
    students[i].passed = newScore >= 50;
}

Bracket assignment plus dot notation lets you update one field at a time without copying the whole struct. The example writes a new score, then recomputes the derived passed flag in the same call so the record stays consistent. The length does not change because the slot already existed.

After adding the four functions, your StudentRegistry contract now covers all the basic array operations on a struct array: push, pop, delete by index, delete on the variable, and field level bracket assignment. Compile in Remix, redeploy, and try each new function from the deploy panel.

Move the last record into the slot you want to drop, then call pop. The targeted record disappears, the last record takes its place, and the length shrinks by one. Solidity copies all of the struct fields in a single storage assignment when you write students[i] = students[last].

function removeAt(uint256 i) external {
    uint256 last = students.length - 1;
    require(i <= last, "out of range");

    if (i != last) {
        students[i] = students[last];
    }
    students.pop();
}

The if (i != last) guard skips a tiny self assignment when the caller asks for the last slot. After the function returns, the array length is one less than before and the previous last student sits at the position that was removed. Names, scores, and passed flags all move together because they live inside the same struct.

Function 6. Return the whole array as one value

Returning the whole array works when the list is small. The return type uses Student[] memory because the caller receives a fresh copy of every record, not a pointer into storage. Add this function next to the rest in StudentRegistry.

function allStudents() external view returns (Student[] memory) {
    return students;
}

Pattern 1. Build a temporary memory array

Memory arrays let you build a temporary record list inside a function without writing to storage. The size is fixed at the moment you create them with new, so you cannot push or pop on a memory array. Set the entries by index after creation. This pattern lives on its own; it does not extend StudentRegistry because the function is pure.

function buildPreview() external pure returns (Student[] memory) {
    Student[] memory preview = new Student[](2);
    preview[0] = Student({ name: "Sample A", score: 90, passed: true });
    preview[1] = Student({ name: "Sample B", score: 30, passed: false });
    return preview;
}

Pattern 2. Declare a fixed length storage array

Fixed length storage struct arrays declare the slot count inside the brackets. You cannot push or pop because the size never changes. Every slot starts at every struct default and you write into the slots by index. This is a separate state variable on its own contract, not an extension of the dynamic StudentRegistry array.

// Three slot finalists array baked into storage.
Student[3] public finalists;

function setFinalist(uint256 i, string memory name, uint256 score) external {
    require(i < 3, "out of range");
    finalists[i] = Student({ name: name, score: score, passed: score >= 50 });
}

Pattern 3. storage reference for repeated field access

When a function touches several fields of the same record, a storage reference saves repeated storage reads. The reference is an alias into the array slot, so writes go straight back to storage. Use memory copies only when you want a snapshot that does not persist.

function bumpScore(uint256 i, uint256 delta) external {
    require(i < students.length, "out of range");
    Student storage s = students[i];
    s.score += delta;
    s.passed = s.score >= 50;
}

The contract below is the full version. The first three functions are the originals: push wrapped as addStudent, indexed read wrapped as getStudent, and the length read wrapped as totalStudents. The remaining six are the additions you walked through in Sections 06 to 08.

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

contract StudentRegistry {
    struct Student {
        string name;
        uint256 score;
        bool passed;
    }

    Student[] public students;

    // Append a new student.
    function addStudent(string memory name, uint256 score) external {
        students.push(Student({
            name: name,
            score: score,
            passed: score >= 50
        }));
    }

    // Read one full record by index.
    function getStudent(uint256 i) external view returns (Student memory) {
        require(i < students.length, "out of range");
        return students[i];
    }

    // Return how many students are on the list.
    function totalStudents() external view returns (uint256) {
        return students.length;
    }

    // Function 1. Remove the most recent student with pop.
    function dropLast() external {
        require(students.length > 0, "empty");
        students.pop();
    }

    // Function 2. Reset one slot with delete by index.
    function clearStudent(uint256 i) external {
        require(i < students.length, "out of range");
        delete students[i];
    }

    // Function 3. Wipe the whole list with delete on the variable.
    function clearAll() external {
        delete students;
    }

    // Function 4. Update one field with direct assignment.
    function updateScore(uint256 i, uint256 newScore) external {
        require(i < students.length, "out of range");
        students[i].score = newScore;
        students[i].passed = newScore >= 50;
    }

    // Function 5. Remove any student with swap and pop.
    function removeAt(uint256 i) external {
        uint256 last = students.length - 1;
        require(i <= last, "out of range");
        if (i != last) {
            students[i] = students[last];
        }
        students.pop();
    }

    // Function 6. Return the whole array as memory.
    function allStudents() external view returns (Student[] memory) {
        return students;
    }
}

Open Remix, paste the contract, compile with the 0.8.20 compiler, and redeploy to the JavaScript VM. The deploy panel now lists nine callable buttons plus the auto generated getter on students. Push a few records with addStudent, call allStudents to see them in order, run updateScore(0, 95) and confirm that passed also flipped, then call removeAt(0) and notice the enrolment order changes because swap and pop is unordered. Every method you have learnt in this post lives in this single file.

Deploy the contract in Remix, push three products, then call restock(1, 50) and confirm the stock on index one jumps by fifty without touching the other fields. Try removeAt(0) next and notice the previous last product now sits at index zero. If the stock update fails, double check that you used a storage reference rather than a memory copy.

The struct array is the bridge between simple value type arrays and the bigger picture of on chain records. For the broader picture on fixed versus dynamic shapes, storage versus memory, and the array plus mapping pattern, read the hub guide on arrays in Solidity. The companion post on structs in Solidity covers struct semantics in detail. To pair the struct array with constant time lookup by id, read mapping with struct. If you missed the value type array series, start with the uint array and walk forward.