Локальные переменые и переменные состояния

Путешествие по Solidity & DeFi

Отправляемся в путь

Основы solidity

0/57

Встреча

Hello, Blockchain!

Структура смарт-контракта

Переменные состояния смарт-контракта

Функции и взаимодействие

Операции с данными — основы

Числовые и логические типы данных

Строки, байты и адреса

Локальные переменые и переменные состояния

Константы и неизменяемые переменные

Функции с множественными возвращаемыми значениями

Модификаторы видимости переменных

Модификаторы видимости функций и поведения

Продвинутые операции и безопасность

Remix IDE — знакомство с платформой

Remix IDE — продвинутые возможности

Основы обработки ошибок

Продвинутая обработка ошибок

Кастомные модификаторы

Массивы - основы упорядоченных данных

Mappings - ассоциативные структуры данных

Структуры и Enums - группировка данных

Размещение данных в памяти

Hardhat — установка и настройка

Hardhat — разработка контрактов

Hardhat — тестирование контрактов

Газ – основы. Часть 1: Единицы и опкоды

Газ – стратегии. Часть 2: Оптимизация и MEV

Оптимизация газа — искусство экономии

События

Прием ETH и payable функции

Три способа отправки эфира

Специальные функции обработки получаемого эфира

Паттерны управления деньгами

Переполнение и версии Solidity

Профессиональные техники математики в DeFi

Основы взаимодействия контрактов

Factory Pattern и создание контрактов

Абстрактные контракты и безопасность

Низкоуровневые вызовы между контрактами

Создание токена с нуля

Стандарт ERC-20 и OpenZeppelin

NFT и стандарт ERC-721

Мульти-токены ERC-1155

Основы безопасности и контроль доступа

Reentrancy и Integer Overflow атаки

Продвинутые атаки и защита

Работа со временем в Ethereum

Свойства блоков и транзакций

Основы стейкинга

ABI - основы и кодирование данных

Межконтрактные вызовы через ABI

Декодирование данных и практическое применение ABI

Хеш-функции и проверка целостности данных

Цифровые подписи и аутентификация

Продвинутая криптография и случайность

Основы DAO — децентрализованные автономные организации

Основы блокчейна

0/9

Блокчейн ноды

Адреса и кошельки в блокчейне

Блокчейн транзакции

Блоки

Консенсус и безопасность

Структура базы данных Ethereum

EVM

Ethereum как протокол

Реализация базы данных Ethereum

Основы криптографии

0/10

Алгоритмическая сложность

Хеш-функции

Майнинг и Proof of Work

Основы шифрования

Симметричные и асимметричные алгоритмы

Цифровые подписи

Кошельки, ключи и адреса

Эллиптические кривые

Факторизация

Деревья Меркла

Мир токенов

Скидки на «Starter» и «Pro» до

Выбрать тариф

Переменные состояния и локальные переменныеАлекс замечает, что переменные в Solidity работают совершенно по-разному в зависимости от того, где они объявлены:
— «Оказывается, место объявления переменной кардинально влияет на то, как она работает, сколько стоит и как долго живет!»
Ключевые термины урокаПеременная состояния (State Variable) — переменная, объявленная на уровне контракта, которая хранится в блокчейне навсегда и доступна всем функциям контракта. Изменения таких переменных требуют значительных затрат стоимости вызова функции.
Локальная переменная (Local Variable) — переменная, объявленная внутри функции, которая существует только во время выполнения этой функции и хранится в памяти EVM. Операции с локальными переменными стоят очень мало стоимости вызова функции.
Storage — постоянное хранилище блокчейна, где хранятся переменные состояния. Каждая запись в storage стоит дорого, но данные сохраняются навсегда.
Memory — временное хранилище EVM, где хранятся локальные переменные во время выполнения функции. Операции с memory дешевые, но данные исчезают после завершения функции.
Область видимости (Scope) — часть кода, где переменная доступна для использования. Локальные переменные доступны только в пределах блока кода, где они объявлены.
Стоимость вызова функции записи в storage — затраты стоимости вызова функции на запись данных в постоянное хранилище блокчейна. Первая запись стоит ~20,000 стоимости вызова функции, последующие изменения ~5,000 стоимости вызова функции.
Оптимизация стоимости вызова функции — техника минимизации затрат на выполнение смарт-контракта путем правильного использования локальных переменных для промежуточных вычислений и минимизации операций записи в storage.
Переменные состояния — память блокчейнаПеременные состояния — это переменные, которые объявляются на уровне контракта и хранятся в блокчейне навсегда.
Синтаксис объявления переменных состоянияПеременные состояния объявляются на уровне контракта (вне функций) по следующему синтаксису:
Solidity
contract ContractName {
    // Синтаксис объявления переменной состояния:
    тип_данных [модификаторы] имя_переменной [= начальное_значение];
﻿
    // Примеры:
    uint256 public balance;                    // Публичная переменная
    string private ownerName;                  // Приватная переменная
    bool internal isActive = true;             // Внутренняя переменная с начальным значением
    address public constant ADMIN = 0x123...; // Публичная константа
    uint256 private immutable creationTime;   // Неизменяемая переменная
}
Основные характеристики переменных состоянияХранятся в блокчейне — каждое изменение записывается в блок и становится частью истории
Доступны всем функциям контракта для чтения и изменения
Сохраняются между вызовами — значения не исчезают после выполнения функций
Стоят дорого — каждое изменение требует стоимости вызова функции за запись в storage
Образуют состояние контракта — именно они определяют текущее состояние смарт-контракта
Solidity
contract BankAccount {
    // === ПЕРЕМЕННЫЕ СОСТОЯНИЯ ===
    // Все эти переменные хранятся в блокчейне
﻿
    string public accountHolder;     // Имя владельца счета
    uint256 public balance;          // Текущий баланс
    bool public isActive;            // Активен ли счет
    address public owner;            // Адрес владельца
    uint256 public lastTransaction;  // Время последней транзакции
﻿
    // Эти переменные доступны всем функциям контракта
    function deposit(uint256 amount) public {
        balance += amount;                    // Изменяем переменную состояния
        lastTransaction = block.timestamp;    // Обновляем время
        // Изменения сохранятся в блокчейне навсегда!
    }
﻿
    function withdraw(uint256 amount) public {
        require(balance >= amount, "Недостаточно средств");
        balance -= amount;                    // Снова изменяем состояние
        lastTransaction = block.timestamp;    // Время обновляется
        // Все изменения останутся после завершения функции
    }
}
Стоимость операций с переменными состоянияАлекс изучает экономику переменных состояния:
Solidity
contract GasExample {
    uint256 public stateVariable = 0;
﻿
    function expensiveOperations() public {
        // Чтение переменной состояния: ~200 стоимости вызова функции
        uint256 currentValue = stateVariable;
﻿
        // Изменение с 0 на не-0: ~20,000 стоимости вызова функции (очень дорого!)
        stateVariable = 100;
﻿
        // Изменение с не-0 на не-0: ~5,000 стоимости вызова функции (дорого)
        stateVariable = 200;
﻿
        // Изменение с не-0 на 0: ~2,500 стоимости вызова функции + возврат части стоимости вызова функции
        stateVariable = 0;
    }
}
— «Вау! Первая запись в переменную стоит в 4 раза дороже последующих изменений. А обнуление переменной даже возвращает часть потраченной стоимости вызова функции!»
Локальные переменные — временные помощникиЛокальные переменные — это переменные, которые объявляются внутри функций и существуют только во время выполнения этой функции.
Синтаксис объявления локальных переменныхЛокальные переменные объявляются внутри функций по следующему синтаксису:
Solidity
contract ContractName {
    function functionName() public {
        // Синтаксис объявления локальной переменной:
        тип_данных имя_переменной [= начальное_значение];
﻿
        // Примеры:
        uint256 temporaryValue;                    // Локальная переменная без начального значения
        string memory userName = "Alex";           // Локальная строка в памяти
        bool isValid = true;                       // Локальная переменная с начальным значением
        address sender = msg.sender;               // Локальная переменная с присвоением
        uint256[] memory numbers = new uint256[](5); // Локальный массив в памяти
    }
Отличия синтаксиса локальных переменных от переменных состояния:Расположение: Локальные переменные объявляются только внутри функций
Модификаторы видимости: У локальных переменных НЕТ модификаторов видимости (public, private, internal)
Модификаторы хранилища: Для сложных типов (массивы, строки, структуры) может указываться memory или storage
Константы и immutable: Локальные переменные НЕ МОГУТ быть constant или immutable
Solidity
contract SyntaxComparison {
    // === ПЕРЕМЕННЫЕ СОСТОЯНИЯ ===
    uint256 public stateVar = 100;           // ✅ Можно использовать модификаторы видимости
    string private constant MESSAGE = "Hi";  // ✅ Можно использовать constant
﻿
    function exampleFunction() public {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        uint256 localVar = 50;               // ✅ Простое объявление
        // uint256 public localPublic = 25;  // ❌ ОШИБКА! Нельзя использовать public
        // uint256 constant LOCAL_CONST = 10; // ❌ ОШИБКА! Нельзя использовать constant
        string memory tempMessage = "Hello"; // ✅ Можно указать memory для сложных типов
    }
}
Основные характеристики локальных переменныхХранятся в памяти — используют временное хранилище EVM
Живут только во время выполнения функции — создаются при входе, уничтожаются при выходе
Дешевые в использовании — операции с ними стоят очень мало стоимости вызова функции
Не сохраняются — значения исчезают после завершения функции
Доступны только внутри функции где объявлены
Solidity
contract Calculator {
    uint256 public totalCalculations = 0;  // Переменная состояния
﻿
    function complexCalculation(uint256 a, uint256 b, uint256 c) public returns (uint256) {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        // Все эти переменные существуют только во время выполнения функции
﻿
        uint256 step1 = a * b;           // Промежуточный результат
        uint256 step2 = step1 + c;       // Еще один промежуточный результат
        uint256 step3 = step2 / 2;       // Финальное вычисление
﻿
        bool isEven = step3 % 2 == 0;    // Проверка четности
﻿
        if (isEven) {
            uint256 bonus = 10;          // Локальная переменная внутри блока
            step3 += bonus;              // Добавляем бонус
        } // bonus исчезает здесь
﻿
        totalCalculations++;             // Изменяем переменную состояния
﻿
        return step3;
        // Все локальные переменные (step1, step2, step3, isEven) исчезают здесь!
    }
}
Экономия стоимости вызова функции с локальными переменнымиSolidity
contract GasComparison {
    uint256 public stateResult;  // Переменная состояния
﻿
    // ДОРОГОЙ способ — все промежуточные значения в состоянии
    function expensiveWay(uint256 a, uint256 b) public {
        stateResult = a + b;        // ~20,000 стоимости вызова функции (первая запись)
        stateResult = stateResult * 2; // ~5,000 стоимости вызова функции
        stateResult = stateResult - 10; // ~5,000 стоимости вызова функции
        // Общая стоимость: ~30,000 стоимости вызова функции
    }
﻿
    // ДЕШЕВЫЙ способ — промежуточные вычисления локально
    function cheapWay(uint256 a, uint256 b) public {
        uint256 temp = a + b;       // ~3 стоимости вызова функции (локальная переменная)
        temp = temp * 2;            // ~3 стоимости вызова функции
        temp = temp - 10;           // ~3 стоимости вызова функции
        stateResult = temp;         // ~20,000 стоимости вызова функции (одна запись в состояние)
        // Общая стоимость: ~20,009 стоимости вызова функции — экономия 33%!
    }
}
— «Невероятно! Использование локальных переменных для промежуточных вычислений может сэкономить треть стоимости вызова функции!»
Области видимости локальных переменныхАлекс изучает, где именно доступны локальные переменные:
Solidity
contract ScopeExample {
    uint256 public stateVar = 100;  // Переменная состояния — доступна везде в контракте
﻿
    function scopeDemo(uint256 param) public pure returns (uint256) {
        uint256 functionVar = 10;   // Доступна во всей функции
﻿
        if (param > 5) {
            uint256 blockVar = 20;  // Доступна только в этом блоке if
            functionVar += blockVar; // Можем использовать обе переменные
﻿
            {
                uint256 innerVar = 30; // Доступна только в этом внутреннем блоке
                blockVar += innerVar;  // Можем использовать все три
                functionVar += innerVar;
            } // innerVar исчезает здесь
﻿
            // innerVar здесь уже недоступна!
            // blockVar все еще доступна
﻿
        } // blockVar исчезает здесь
﻿
        // Здесь доступны только functionVar и param
        // blockVar и innerVar уже недоступны
﻿
        return functionVar;
    } // functionVar и param исчезают здесь
}
Практический примерАлекс создает простой пример, показывающий разницу между переменными состояния и локальными переменными:
Solidity
contract SimpleBank {
    // === ПЕРЕМЕННЫЕ СОСТОЯНИЯ ===
    // Эта информация должна сохраняться в блокчейне навсегда
    string public bankName = "Alex Bank";   // Название банка
    uint256 public totalBalance;            // Общий баланс банка
    address public owner;                   // Владелец банка
    bool public isOpen = true;              // Работает ли банк
﻿
    constructor() {
        owner = msg.sender;  // Устанавливаем владельца
        totalBalance = 0;    // Начальный баланс
    }
﻿
    function makeDeposit(uint256 amount) public returns (uint256) {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        // Эти переменные нужны только для вычислений в этой функции
﻿
        uint256 fee = amount / 100;          // Комиссия 1%
        uint256 depositAmount = amount - fee; // Сумма к зачислению
        bool isLargeDeposit = amount > 1000;  // Проверка крупного депозита
﻿
        // Если депозит крупный, даем бонус
        if (isLargeDeposit) {
            uint256 bonus = 50;              // Локальная переменная только в этом блоке
            depositAmount += bonus;          // Добавляем бонус
        } // переменная bonus исчезает здесь
﻿
        // Обновляем переменную состояния (сохраняется навсегда)
        totalBalance += depositAmount;
﻿
        return depositAmount;
﻿
        // Все локальные переменные (fee, depositAmount, isLargeDeposit, bonus)
        // исчезают здесь, но totalBalance остается в блокчейне!
    }
﻿
    function withdraw(uint256 amount) public returns (bool) {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        uint256 fee = amount / 50;           // Комиссия за снятие 2%
        uint256 totalCost = amount + fee;    // Общая сумма к списанию
        bool hasEnoughFunds = totalBalance >= totalCost; // Проверка средств
﻿
        if (!hasEnoughFunds) {
            return false;  // Недостаточно средств
        }
﻿
        // Обновляем состояние (ДОРОГАЯ операция)
        totalBalance -= totalCost;
﻿
        return true;
﻿
        // Локальные переменные исчезают, но изменения в totalBalance остаются!
    }
}
Лучшие практики использования переменныхАлекс выводит правила оптимального использования переменных:
1. Используй переменные состояния для данных, которые должны сохранятьсяSolidity
contract UserProfile {
    // ✅ ПРАВИЛЬНО — эти данные должны сохраняться
    string public userName;
    uint256 public registrationDate;
    uint256 public lastLoginTime;
    bool public isVerified;
}
2. Используй локальные переменные для временных вычисленийSolidity
contract MathOperations {
    uint256 public result;
﻿
    function complexCalculation(uint256 a, uint256 b, uint256 c) public {
        // ✅ ПРАВИЛЬНО — промежуточные вычисления локально
        uint256 temp1 = a * b;
        uint256 temp2 = temp1 + c;
        uint256 temp3 = temp2 / 2;
﻿
        result = temp3; // Только финальный результат в состояние
    }
}
3. Минимизируй операции записи в переменные состоянияSolidity
contract Counter {
    uint256 public count;
﻿
    // ❌ ПЛОХО — много записей в состояние
    function badIncrement() public {
        count++;        // Запись 1
        count++;        // Запись 2
        count++;        // Запись 3
    }
﻿
    // ✅ ХОРОШО — одна запись в состояние
    function goodIncrement() public {
        uint256 temp = count; // Читаем один раз
        temp += 3;            // Вычисляем локально
        count = temp;         // Записываем один раз
    }
}
4. Объявляй переменные в нужной области видимостиSolidity
contract ScopeOptimization {
    function processData(uint256[] memory data) public pure returns (uint256) {
        uint256 total = 0;
﻿
        for (uint256 i = 0; i < data.length; i++) {
            // ✅ ПРАВИЛЬНО — переменная объявлена в нужном месте
            if (data[i] > 10) {
                uint256 bonus = data[i] * 2; // Нужна только здесь
                total += bonus;
            }
        }
﻿
        return total;
    }
}
— «Теперь я понимаю разницу! Переменные состояния — это как публикация информация в газете: опубликовать свой текст стоит денег, но про него узнают все, и он навсегда сохранится в истории. А локальные переменные — как листочек для черновых вычислений: дешево использовать, но подойдет только для временных записей.»
Практическое задание по переменным состояния и локальным переменнымАлекс изучил разницу между переменными состояния и локальными переменными, но теперь ему нужна практика. Он решил создать контракт системы голосования, но столкнулся с проблемой оптимизации стоимости вызова функции.
— «Я понимаю теорию, но как применить это на практике? Мой контракт голосования работает, но тратит слишком много стоимости вызова функции. Нужно оптимизировать использование переменных!»
Помоги Алексу оптимизировать контракт, правильно выбрав между переменными состояния и локальными переменными для максимальной экономии стоимости вызова функции.
Практические задания
Загрузка...
Дополнительные материалыОфициальная документация﻿Solidity by example﻿
﻿Solidity Documentation - Variables — подробное описание переменных состояния
﻿Solidity Documentation - Scoping — области видимости переменных

Скидки на «Starter» и «Pro» до

Выбрать тариф

Переменные состояния и локальные переменныеАлекс замечает, что переменные в Solidity работают совершенно по-разному в зависимости от того, где они объявлены:
— «Оказывается, место объявления переменной кардинально влияет на то, как она работает, сколько стоит и как долго живет!»
Ключевые термины урокаПеременная состояния (State Variable) — переменная, объявленная на уровне контракта, которая хранится в блокчейне навсегда и доступна всем функциям контракта. Изменения таких переменных требуют значительных затрат стоимости вызова функции.
Локальная переменная (Local Variable) — переменная, объявленная внутри функции, которая существует только во время выполнения этой функции и хранится в памяти EVM. Операции с локальными переменными стоят очень мало стоимости вызова функции.
Storage — постоянное хранилище блокчейна, где хранятся переменные состояния. Каждая запись в storage стоит дорого, но данные сохраняются навсегда.
Memory — временное хранилище EVM, где хранятся локальные переменные во время выполнения функции. Операции с memory дешевые, но данные исчезают после завершения функции.
Область видимости (Scope) — часть кода, где переменная доступна для использования. Локальные переменные доступны только в пределах блока кода, где они объявлены.
Стоимость вызова функции записи в storage — затраты стоимости вызова функции на запись данных в постоянное хранилище блокчейна. Первая запись стоит ~20,000 стоимости вызова функции, последующие изменения ~5,000 стоимости вызова функции.
Оптимизация стоимости вызова функции — техника минимизации затрат на выполнение смарт-контракта путем правильного использования локальных переменных для промежуточных вычислений и минимизации операций записи в storage.
Переменные состояния — память блокчейнаПеременные состояния — это переменные, которые объявляются на уровне контракта и хранятся в блокчейне навсегда.
Синтаксис объявления переменных состоянияПеременные состояния объявляются на уровне контракта (вне функций) по следующему синтаксису:
Solidity
contract ContractName {
    // Синтаксис объявления переменной состояния:
    тип_данных [модификаторы] имя_переменной [= начальное_значение];
﻿
    // Примеры:
    uint256 public balance;                    // Публичная переменная
    string private ownerName;                  // Приватная переменная
    bool internal isActive = true;             // Внутренняя переменная с начальным значением
    address public constant ADMIN = 0x123...; // Публичная константа
    uint256 private immutable creationTime;   // Неизменяемая переменная
}
Основные характеристики переменных состоянияХранятся в блокчейне — каждое изменение записывается в блок и становится частью истории
Доступны всем функциям контракта для чтения и изменения
Сохраняются между вызовами — значения не исчезают после выполнения функций
Стоят дорого — каждое изменение требует стоимости вызова функции за запись в storage
Образуют состояние контракта — именно они определяют текущее состояние смарт-контракта
Solidity
contract BankAccount {
    // === ПЕРЕМЕННЫЕ СОСТОЯНИЯ ===
    // Все эти переменные хранятся в блокчейне
﻿
    string public accountHolder;     // Имя владельца счета
    uint256 public balance;          // Текущий баланс
    bool public isActive;            // Активен ли счет
    address public owner;            // Адрес владельца
    uint256 public lastTransaction;  // Время последней транзакции
﻿
    // Эти переменные доступны всем функциям контракта
    function deposit(uint256 amount) public {
        balance += amount;                    // Изменяем переменную состояния
        lastTransaction = block.timestamp;    // Обновляем время
        // Изменения сохранятся в блокчейне навсегда!
    }
﻿
    function withdraw(uint256 amount) public {
        require(balance >= amount, "Недостаточно средств");
        balance -= amount;                    // Снова изменяем состояние
        lastTransaction = block.timestamp;    // Время обновляется
        // Все изменения останутся после завершения функции
    }
}
Стоимость операций с переменными состоянияАлекс изучает экономику переменных состояния:
Solidity
contract GasExample {
    uint256 public stateVariable = 0;
﻿
    function expensiveOperations() public {
        // Чтение переменной состояния: ~200 стоимости вызова функции
        uint256 currentValue = stateVariable;
﻿
        // Изменение с 0 на не-0: ~20,000 стоимости вызова функции (очень дорого!)
        stateVariable = 100;
﻿
        // Изменение с не-0 на не-0: ~5,000 стоимости вызова функции (дорого)
        stateVariable = 200;
﻿
        // Изменение с не-0 на 0: ~2,500 стоимости вызова функции + возврат части стоимости вызова функции
        stateVariable = 0;
    }
}
— «Вау! Первая запись в переменную стоит в 4 раза дороже последующих изменений. А обнуление переменной даже возвращает часть потраченной стоимости вызова функции!»
Локальные переменные — временные помощникиЛокальные переменные — это переменные, которые объявляются внутри функций и существуют только во время выполнения этой функции.
Синтаксис объявления локальных переменныхЛокальные переменные объявляются внутри функций по следующему синтаксису:
Solidity
contract ContractName {
    function functionName() public {
        // Синтаксис объявления локальной переменной:
        тип_данных имя_переменной [= начальное_значение];
﻿
        // Примеры:
        uint256 temporaryValue;                    // Локальная переменная без начального значения
        string memory userName = "Alex";           // Локальная строка в памяти
        bool isValid = true;                       // Локальная переменная с начальным значением
        address sender = msg.sender;               // Локальная переменная с присвоением
        uint256[] memory numbers = new uint256[](5); // Локальный массив в памяти
    }
Отличия синтаксиса локальных переменных от переменных состояния:Расположение: Локальные переменные объявляются только внутри функций
Модификаторы видимости: У локальных переменных НЕТ модификаторов видимости (public, private, internal)
Модификаторы хранилища: Для сложных типов (массивы, строки, структуры) может указываться memory или storage
Константы и immutable: Локальные переменные НЕ МОГУТ быть constant или immutable
Solidity
contract SyntaxComparison {
    // === ПЕРЕМЕННЫЕ СОСТОЯНИЯ ===
    uint256 public stateVar = 100;           // ✅ Можно использовать модификаторы видимости
    string private constant MESSAGE = "Hi";  // ✅ Можно использовать constant
﻿
    function exampleFunction() public {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        uint256 localVar = 50;               // ✅ Простое объявление
        // uint256 public localPublic = 25;  // ❌ ОШИБКА! Нельзя использовать public
        // uint256 constant LOCAL_CONST = 10; // ❌ ОШИБКА! Нельзя использовать constant
        string memory tempMessage = "Hello"; // ✅ Можно указать memory для сложных типов
    }
}
Основные характеристики локальных переменныхХранятся в памяти — используют временное хранилище EVM
Живут только во время выполнения функции — создаются при входе, уничтожаются при выходе
Дешевые в использовании — операции с ними стоят очень мало стоимости вызова функции
Не сохраняются — значения исчезают после завершения функции
Доступны только внутри функции где объявлены
Solidity
contract Calculator {
    uint256 public totalCalculations = 0;  // Переменная состояния
﻿
    function complexCalculation(uint256 a, uint256 b, uint256 c) public returns (uint256) {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        // Все эти переменные существуют только во время выполнения функции
﻿
        uint256 step1 = a * b;           // Промежуточный результат
        uint256 step2 = step1 + c;       // Еще один промежуточный результат
        uint256 step3 = step2 / 2;       // Финальное вычисление
﻿
        bool isEven = step3 % 2 == 0;    // Проверка четности
﻿
        if (isEven) {
            uint256 bonus = 10;          // Локальная переменная внутри блока
            step3 += bonus;              // Добавляем бонус
        } // bonus исчезает здесь
﻿
        totalCalculations++;             // Изменяем переменную состояния
﻿
        return step3;
        // Все локальные переменные (step1, step2, step3, isEven) исчезают здесь!
    }
}
Экономия стоимости вызова функции с локальными переменнымиSolidity
contract GasComparison {
    uint256 public stateResult;  // Переменная состояния
﻿
    // ДОРОГОЙ способ — все промежуточные значения в состоянии
    function expensiveWay(uint256 a, uint256 b) public {
        stateResult = a + b;        // ~20,000 стоимости вызова функции (первая запись)
        stateResult = stateResult * 2; // ~5,000 стоимости вызова функции
        stateResult = stateResult - 10; // ~5,000 стоимости вызова функции
        // Общая стоимость: ~30,000 стоимости вызова функции
    }
﻿
    // ДЕШЕВЫЙ способ — промежуточные вычисления локально
    function cheapWay(uint256 a, uint256 b) public {
        uint256 temp = a + b;       // ~3 стоимости вызова функции (локальная переменная)
        temp = temp * 2;            // ~3 стоимости вызова функции
        temp = temp - 10;           // ~3 стоимости вызова функции
        stateResult = temp;         // ~20,000 стоимости вызова функции (одна запись в состояние)
        // Общая стоимость: ~20,009 стоимости вызова функции — экономия 33%!
    }
}
— «Невероятно! Использование локальных переменных для промежуточных вычислений может сэкономить треть стоимости вызова функции!»
Области видимости локальных переменныхАлекс изучает, где именно доступны локальные переменные:
Solidity
contract ScopeExample {
    uint256 public stateVar = 100;  // Переменная состояния — доступна везде в контракте
﻿
    function scopeDemo(uint256 param) public pure returns (uint256) {
        uint256 functionVar = 10;   // Доступна во всей функции
﻿
        if (param > 5) {
            uint256 blockVar = 20;  // Доступна только в этом блоке if
            functionVar += blockVar; // Можем использовать обе переменные
﻿
            {
                uint256 innerVar = 30; // Доступна только в этом внутреннем блоке
                blockVar += innerVar;  // Можем использовать все три
                functionVar += innerVar;
            } // innerVar исчезает здесь
﻿
            // innerVar здесь уже недоступна!
            // blockVar все еще доступна
﻿
        } // blockVar исчезает здесь
﻿
        // Здесь доступны только functionVar и param
        // blockVar и innerVar уже недоступны
﻿
        return functionVar;
    } // functionVar и param исчезают здесь
}
Практический примерАлекс создает простой пример, показывающий разницу между переменными состояния и локальными переменными:
Solidity
contract SimpleBank {
    // === ПЕРЕМЕННЫЕ СОСТОЯНИЯ ===
    // Эта информация должна сохраняться в блокчейне навсегда
    string public bankName = "Alex Bank";   // Название банка
    uint256 public totalBalance;            // Общий баланс банка
    address public owner;                   // Владелец банка
    bool public isOpen = true;              // Работает ли банк
﻿
    constructor() {
        owner = msg.sender;  // Устанавливаем владельца
        totalBalance = 0;    // Начальный баланс
    }
﻿
    function makeDeposit(uint256 amount) public returns (uint256) {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        // Эти переменные нужны только для вычислений в этой функции
﻿
        uint256 fee = amount / 100;          // Комиссия 1%
        uint256 depositAmount = amount - fee; // Сумма к зачислению
        bool isLargeDeposit = amount > 1000;  // Проверка крупного депозита
﻿
        // Если депозит крупный, даем бонус
        if (isLargeDeposit) {
            uint256 bonus = 50;              // Локальная переменная только в этом блоке
            depositAmount += bonus;          // Добавляем бонус
        } // переменная bonus исчезает здесь
﻿
        // Обновляем переменную состояния (сохраняется навсегда)
        totalBalance += depositAmount;
﻿
        return depositAmount;
﻿
        // Все локальные переменные (fee, depositAmount, isLargeDeposit, bonus)
        // исчезают здесь, но totalBalance остается в блокчейне!
    }
﻿
    function withdraw(uint256 amount) public returns (bool) {
        // === ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ ===
        uint256 fee = amount / 50;           // Комиссия за снятие 2%
        uint256 totalCost = amount + fee;    // Общая сумма к списанию
        bool hasEnoughFunds = totalBalance >= totalCost; // Проверка средств
﻿
        if (!hasEnoughFunds) {
            return false;  // Недостаточно средств
        }
﻿
        // Обновляем состояние (ДОРОГАЯ операция)
        totalBalance -= totalCost;
﻿
        return true;
﻿
        // Локальные переменные исчезают, но изменения в totalBalance остаются!
    }
}
Лучшие практики использования переменныхАлекс выводит правила оптимального использования переменных:
1. Используй переменные состояния для данных, которые должны сохранятьсяSolidity
contract UserProfile {
    // ✅ ПРАВИЛЬНО — эти данные должны сохраняться
    string public userName;
    uint256 public registrationDate;
    uint256 public lastLoginTime;
    bool public isVerified;
}
2. Используй локальные переменные для временных вычисленийSolidity
contract MathOperations {
    uint256 public result;
﻿
    function complexCalculation(uint256 a, uint256 b, uint256 c) public {
        // ✅ ПРАВИЛЬНО — промежуточные вычисления локально
        uint256 temp1 = a * b;
        uint256 temp2 = temp1 + c;
        uint256 temp3 = temp2 / 2;
﻿
        result = temp3; // Только финальный результат в состояние
    }
}
3. Минимизируй операции записи в переменные состоянияSolidity
contract Counter {
    uint256 public count;
﻿
    // ❌ ПЛОХО — много записей в состояние
    function badIncrement() public {
        count++;        // Запись 1
        count++;        // Запись 2
        count++;        // Запись 3
    }
﻿
    // ✅ ХОРОШО — одна запись в состояние
    function goodIncrement() public {
        uint256 temp = count; // Читаем один раз
        temp += 3;            // Вычисляем локально
        count = temp;         // Записываем один раз
    }
}
4. Объявляй переменные в нужной области видимостиSolidity
contract ScopeOptimization {
    function processData(uint256[] memory data) public pure returns (uint256) {
        uint256 total = 0;
﻿
        for (uint256 i = 0; i < data.length; i++) {
            // ✅ ПРАВИЛЬНО — переменная объявлена в нужном месте
            if (data[i] > 10) {
                uint256 bonus = data[i] * 2; // Нужна только здесь
                total += bonus;
            }
        }
﻿
        return total;
    }
}
— «Теперь я понимаю разницу! Переменные состояния — это как публикация информация в газете: опубликовать свой текст стоит денег, но про него узнают все, и он навсегда сохранится в истории. А локальные переменные — как листочек для черновых вычислений: дешево использовать, но подойдет только для временных записей.»
Практическое задание по переменным состояния и локальным переменнымАлекс изучил разницу между переменными состояния и локальными переменными, но теперь ему нужна практика. Он решил создать контракт системы голосования, но столкнулся с проблемой оптимизации стоимости вызова функции.
— «Я понимаю теорию, но как применить это на практике? Мой контракт голосования работает, но тратит слишком много стоимости вызова функции. Нужно оптимизировать использование переменных!»
Помоги Алексу оптимизировать контракт, правильно выбрав между переменными состояния и локальными переменными для максимальной экономии стоимости вызова функции.
Практические задания
Загрузка...
Дополнительные материалыОфициальная документация﻿Solidity by example﻿
﻿Solidity Documentation - Variables — подробное описание переменных состояния
﻿Solidity Documentation - Scoping — области видимости переменных