Understanding Solidity Data Types and Smart Contracts

Solidity offers various data types, including uint, int, string, and bytes, to define variables in smart contracts.

### Understanding Solidity Data Types and Variables
* 📜 In Solidity, you can easily use your MetaMask address by **copying and pasting it into Remix**, ensuring to **add a semicolon** to denote the end of the statement.
* 🐱 When working with bytes, a **bytes32 object** can be defined, such as `bytes32 object = "cat";`, since strings are essentially bytes objects for text, allowing for **easy conversion**.
* 🔍 It's important to note that bytes can vary in size, with types like **bytes2**, **bytes4**, and up to **bytes32**, while the default for unspecified bytes is **bytes** and **256**.
* 🧮 For clarity in coding, it's recommended to **explicitly define types**, such as using `uint256` instead of `uint`, to avoid confusion about the **bit size being used**.
* ⚖ In Solidity, integers can be positive or negative, and when defining a variable like `int favoriteNum = -88;`, you can also choose to declare it as a **positive number**.
* 🔢 Default values for variables are automatically assigned; for example, a `uint256` variable will default to **zero** if not initialized, which is similar to explicitly setting it as `uint256 favoriteNum = **0**;`.
* 📊 The concept of **variables in Solidity** is fundamental, as they hold different values of specified types, such as a boolean variable `hasFavoriteNumber`, which indicates whether someone has a **favorite number**.
* 📚 For further learning, the Solidity documentation provides a **comprehensive overview of various data types**, including **booleans, unsigned integers, and addresses**, which are **essential for building smart contracts**.

hypothetically, we could deploy this smart contract right now. This is a valid contract, although it doesn't do anything. But congratulations, technically, with just this little piece of code, you've written your first smart contract. I spelled version of so we're going to correct that slitty has many different types of things that you can build in these smart contracts, many different data types or just types. If you go to the slitty documentation at docs.solutitylang.org, again, link to this in the GitHub, we can select the types section on the left-hand side to learn more about solidity types. If you want to get a holistic view of all the different types, you can go ahead and read this documentation. Some of the basic types are going to be Boolean, Boolean uint, and an address and bytes. Bytes is a lower-level type, which we'll talk about in a little bit. A Boolean is some type of true-false value. A uint is going to be an unsigned integer, AKA a positive whole number, meaning no decimals, no fractions. An integer is going to be a signed whole

number meaning it could be positive or negative, but again is a whole number. And then we have an address, which is going to be, well, an address. It's very similar to if we open up our MetaMask and we click this account here. It's going to be something like this. There are some other types as well and ways to create your own custom types, but we'll learn more about that later on. We can use these different types to define different variables. Variables are essentially holders for different values, and these values can have one of these types. For example, we could create a variable called hasFavoriteNumber, which would represent if somebody has a favorite number. This hasFavoriteNumber could be true or false, either they do have a favorite number or they don't. To tell Solidity that this hasFavoriteNumber is a true/false or a Boolean, we would add this bool keyword before hasFavoriteNumber. So, this hasFavoriteNumber is going to be either true or false, and to set its value, we're going to give it this little sign and say true.

so now has favorite number is a variable that represents true. We could also say has favorite number is false, meaning that somebody doesn't have a favorite number. For a unit, which again is an unsigned integer, we could say uint favorite number equals 88. This means that this variable favorite number is going to be 88. A uint and int are actually special in that we can actually specify how many bits or bytes that we want to use. For example, we could say U and 256. U and 256 specifies this variable favorite number has 256 bits. We're not going to go over bits and bytes in depth right now, but if you want to get a quick refresher, we've left a link in the GitHub repo associated with this course to give you an overview of bits versus bytes and how they work. An easier way to think about this is really just how big can it get. The bigger the number over here, the bigger this favorite number can be. The maximum size is a uint 256, and if you don't specify

the unit 256. It defaults to being Au and 256. So this and this are the same thing. This this same thing. You could also have 8 bits, 16 bits, 64 bits, etc. Oftentimes it's better when we're writing our code for a readability standpoint to be as explicit as possible. So you'll see me pretty much always writing u in 256 because I want to be very explicit with how many bits I'm using for u and 256 even though they mean the same thing. Instead of a u into 56, we could also have this be an INT 256. And actually, let's add that Boolean back up here now. An INT can actually be positive or negative. So we could have our favorite number be negative 88 if we wanted to. We can also have strings or text variables, which I didn't name up here, but I'll say why in just a minute. We could say string favorite num in text equals 88. Let's actually make this positive 88 even though an inch could be positive or

negative. I'll put this little semicolon here. You'll notice that at the end of every one of these lines, I'm adding this semicolon. The semicolon is how you can tell Solidity that a statement has completed. So, this semicolon is saying the end of this line is right here. If we wanted to, we could put all of our code on the same line like this, and this would compile fine. It just looks really ugly, so we always want to put our code on a new line after the semicolon. A string in Solidity is basically text that represents, well, words. So, I could say 88 instead of having 88 in here. To tell Solidity that something is a string, you have to put it in between quotes. I could put really any combination of characters in here, even like hello or follow Patrick on Twitter. And let's actually do uint256 here, favorite number, and we'll do it into 56 favorite, and equals negative 88. This way, we'll just have an example of all these different types on screen. We can also do an address, so we can say

address my address equals and we can go into our metamask. Copy the address and paste it right into remix and add that semicolon. And now we have our address type in remix. And then finally down here we're going to say a bytes 32 object. A volt bytes 32 equals cat. And we're going to put it in quotes just like we did the string up here. And what's interesting about the string object is that strings are actually secretly just bytes objects specifically for text. So a string can actually get converted to a bytes object really easily because under the hood they're essentially the same thing. Bytes typically look like something like Xerox and a whole bunch of random numbers and letters that represent the hex of whatever the bytes is and can often be represented as strings like cat. We'll talk about bytes more in the future. Similar to uint 256 and into 56 you can have different size bytes like bytes too, two bytes, bytes four, bytes eight, etc. All the way up to 32. You can also have just straight up bytes and not have

a number after, but that's a slightly different type, and we'll go over that later as well. You went like this, and U and 256 are the same thing, but a bytes 32 and a bytes with nothing are actually different. So, keep that in mind for now. The largest bytes, like I was saying, is actually 32. So, for example, we can't do 8 bytes 64, and if we type that in here, this remix actually goes, Hey, there's an issue here. And if we try to compile this, we scroll down, we'll again see this little error code here and this little arrow pop up. It even gives us an output declaration error, Identifier not found or not unique. It gives us the line, and we can say, Ah, whoops-a-daisy, this should be a bytes 32. And we can go back and compile this for our simple storage contract. Let's say that we only want to store a favorite number. This contract is going to be a contract that allows us to store our favorite number and some different people's favorite numbers as

well, so we're going to go ahead and delete everything except for the unit 256 favorite number. So, we're going to go ahead and delete everything, and boom. And we'll pick a smaller favorite number just to make it a little mentally easier. Now, these variables actually have default values. So, for example, if I don't set my favorite number to anything, and I have a line that looks like this, you'll see that this actually compiles fine. Favorite number will actually get defaulted to zero, and all of these types have a different default value. Um, 256 is zero, booleans is false, etc. So, saying U 256 favorite number and not having an equal sign after here is the same as doing U and 256 favorite number equals zero. So, for now, let's not initialize it to anything so that favor number starts off as zero. And remember, as you're coding along here and typing along with me, if you get confused, make sure to write your own comments. For example, we can say favorite number gets initialized to zero if no value is

Lesson 2 Part 3 | Solidity Types - Solidity & Foundry Full Course

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


Cyfrin Audits

Introduction to Smart Contracts and Solidity Types

Smart contracts can be deployed with just a small piece of code, marking the creation of your first contract.

Solidity offers various data types, including Boolean, uint, address, and bytes, which can be explored in detail through the documentation.

Basic types include Boolean for true-false values, uint for unsigned integers (positive whole numbers), and bytes as a lower-level type.

Solidity uses different types to define variables, such as whole numbers, addresses, and Booleans.

Variables act as holders for values, and their types determine the kind of values they can hold.

The largest byte size in Solidity is 32, and using an incorrect byte size will result in a compilation error.

Understanding Variable Types and Default Values

Variables can be defined using different types, such as u256 and INT256, which can represent the same value.

It's important to be explicit with variable definitions for readability.

Each variable type has a default value, and if not initialized, they will default to values like zero for u256 and false for booleans.

Understanding Semicolons and Data Types in Solidity

In Solidity, a semicolon indicates the end of a statement, and code can be placed on the same line, but it's cleaner to use new lines.

Strings in Solidity represent text and must be enclosed in quotes.

Variables can be defined with different data types, such as uint256 for unsigned integers, and the number of bits can be specified for these variables.

Working with Addresses and Bytes in Remix

Copy your address from MetaMask and paste it into Remix, adding a semicolon.

Define a bytes32 object in Remix, using a string like "cat" in quotes.

Bytes objects can easily be converted from strings, and they come in different sizes, ranging from bytes2 to bytes32.