this refers to the instance of the contract where the call is made (you can have multiple instances of the same contract).

address(this) refers to the address of the instance of the contract where the call is being made.

msg.sender refers to the address where the contract is being called from.

Therefore, address(this) and msg.sender are two unique addresses, the first referring to the address of the contract instance and the second referring to the address where the contract call originated from.

Prior to version 0.5.0, Solidity allowed address members to be accessed by a contract instance, for example this.balance. This is now forbidden and an explicit conversion to address must be done: address(this).balance.

Source: https://docs.soliditylang.org/en/v0.5.0/units-and-global-variables.html

So unless you're using deprecated version of Solidity (0.4.x and older), you need to use the conversion to address(this)

keccak256(abi.encodePacked(address(this)), num)

address[] is a type, an array of addresses. You can think of it as a list of addresses.

The square brackets, [], are use to specify that this type is an array.

You can create an array of many things, like an array of uint256 numbers:

uint256[] numbers;

And many more with a similar syntax.

Many languages use the [] to create or declare an array. Like Javascript: const numbers = [];. We can usually initiate an array with values, like in js: const numbers = [1,2,3,4,5];. In Solidity it would look like this for an array of uint256 numbers in storage: uint256[] numbers = [1,2,3,4];

In your case, an array of addresses can be declared as a state variable as follows:

address[] admins;

And then, in another function you can add addresses to that array:

function addAdmin(address adminAddress) public onlyOwner {
   admins.push(adminAddress);
}

Of if you know the address before hand you can hard code them while you declare the array of addresses, like this:

address[] admins = [0x66B0b1d2930059407DcC30F1A2305435fc37315E, 0x6827b8f6cc60497d9bf5210d602C0EcaFDF7C405];

Arrays are really useful to hold a collection of things, objects, numbers, addresses, strings, etc.

We access arrays by index, starting at index 0 for the first element in most programming languages. If I want to access the first element of the array, then I do:

admins[0];

For the second:

admins[1];

And so on. Or in a loop:

for(uint256 i = 0; i < admins.length; i++) {
  address adminAddress = admins[i];
  // ...
  // do something with adminAddress
}

And so on.

Solidity has many rules for arrays. State and local arrays are usually declared differently and used a bit differently in some cases. To learn more about them you can check the documentation: https://docs.soliditylang.org/en/latest/types.html#arrays

I hope it has helped.

Enter your address in https://etherscan.io/ and copy the uppercase/lowercase checksummed version and paste it into your solidity code.

contract Sample {
  address constant public myAddress = 0xE0f5206BBD039e7b0592d8918820024e2a7437b9;
  uint public vari;
  function setVari(uint a) {
    if(msg.sender == myAddress) {
      vari = a;
    }
  }  
}

And the warning message will disappear. The compiler checks the checksummed address for validity.

But I just checked your code with the checksummed address in Remix and I get a new warning message:

Untitled4:4:39: Warning: Initial value for constant variable has to be compile-time constant. This will fail to compile with the next breaking version change.
  address constant public myAddress = 0xE0f5206BBD039e7b0592d8918820024e2a7437b9;
                                      ^----------------------------------------^

This second error will disappear if you remove the constant modifier.