# Strings & Bytes

### Strings

1. ***The important point here is string arrays are static and push and pop are not applicable however there is away to make this possible using bytes***
    
2. In Solidity, a string is a dynamically sized array of UTF-8 encoded characters, represented by the `string` type. Unlike fixed-size types like `uint` or `bytes32`, the size of a string can be changed dynamically during runtime.
    
3. You can declare a string variable like this:
    

```solidity
string myString;
```

1. You can also initialize a string variable with a string literal, like this:
    

```solidity
string myString = "Hello, world!";
```

1. You can access individual characters in a string using array indexing, like this:
    

```solidity
char myChar = myString[0];
```

1. In this example, we access the first character of `myString` and assign it to the `myChar` variable.
    
2. One thing to note is that strings are stored in memory by default, which means that they are more expensive to use in terms of gas costs than other types like `uint` or `bool`. To save on gas costs, you can use the `bytes` type instead of `string` in cases where you need to store a variable-length sequence of bytes.
    

To convert a string to a `bytes` array in Solidity, you can use the `bytes()` function, like this:

```solidity
string myString = "Hello, world!";
bytes memory myBytes = bytes(myString);
```

In this example, we create a `bytes` array called `myBytes` that contains the UTF-8 encoded bytes of the `myString` variable.

### Bytes

1. In Solidity, you can create dynamic arrays of any type using the `new` keyword. However, the one exception to this is the `bytes` type.
    
2. The reason for this is that `bytes` is a special type in Solidity that represents an array of bytes with a fixed length. Unlike other types like `uint` or `string`, `bytes` is not a dynamically sized type.
    
3. When you declare a `bytes` variable, you need to specify the number of bytes that the array will hold, like this:
    
    ```solidity
    bytes32 myBytes;
    ```
    
    1. In this example, `myBytes` is a `bytes` variable with a length of 32 bytes.
        
    2. Because `bytes` is a fixed-size type, you cannot create dynamic arrays of `bytes` using the `new` keyword like you can with other types.
        
    3. Instead, if you need a dynamically sized byte array, you can use the `bytes` or `byte[]` type instead, which are similar to `string` in that they are dynamically sized arrays of bytes.
        
    
    For example, if you need a dynamically sized byte array, you can declare it like this:
    
    ```solidity
    bytes myDynamicBytes;
    ```
    
    In this example, `myDynamicBytes` is a dynamically sized byte array that can hold any number of bytes. You can resize this array as needed using the `push` and `pop` methods
    

### Curios Case Of Byte array

1. When you create a `bytes` variable in Solidity, you can initialize it using a string literal like this:
    

```solidity
bytes memory jeevan = bytes("hello");
```

1. In this example, `jeevan` is a `bytes` variable that is initialized with the value "hello". Note that the `memory` keyword is used to specify that the variable is stored in memory.
    
2. However, although `jeevan` is a dynamic array, you cannot use the `push()` method to add new elements to it. This is because `bytes` arrays are fixed-size arrays of bytes, and their size cannot be changed once they are declared.
    
3. To modify the value of `jeevan`, you need to use array indexing to access and modify individual bytes in the array:
    

```solidity
jeevan[0] = "H";
```

1. In this example, we use array indexing to change the first byte in `jeevan` from "h" to "H". However, we cannot add new bytes to `jeevan` using the `push()` method or any other similar method.