## Console Logging

* Similar to Hardhat's console functions.
* You can use it in calls and transactions. It also works with view and pure functions.
* It always works, regardless of the call or transaction failing or being successful.
* To use it you need import it:
  * `import {console} from "forge-std/console.sol";{:solidity}`
* You can call console.log with up to 4 parameters in any order of following types:
  * `uint`
  * `string`
  * `bool`
  * `address`
* There's also the single parameter API for the types above, and additionally bytes, bytes1... up to bytes32:
  * `console.logInt(int i)`
  * `console.logUint(uint i)`
  * `console.logString(string memory s)`
  * `console.logBool(bool b)`
  * `console.logAddress(address a)`
  * `console.logBytes(bytes memory b)`
  * `console.logBytes1(bytes1 b)`
  * `console.logBytes2(bytes2 b)`
  * ...
  * `console.logBytes32(bytes32 b)`
* console.log implements the same formatting options that can be found in Hardhat's console.log.
  * Example: `console.log("Changing owner from %s to %s", currentOwner, newOwner)`
* console.log is implemented in standard Solidity and it is compatible Anvil and Hardhat Networks.
* console.log calls can run in other networks, like mainnet, kovan, ropsten, etc. They do nothing in those networks, but do spend a minimal amount of gas.

### `console.log(format[,...args])`

The `console.log()` method prints a formatted string using the first argument as a printf-like format string which can contain zero or more format specifiers. Each specifier is replaced with the converted value from the corresponding argument. Supported specifiers are:

* `%s`: String will be used to convert all values to a human-readable string. `uint256`, `int256` and `bytes` values are converted to their `0x` hex encoded values.
* `%d`: Number will be used to convert all values to a human-readable string. This is identical to `%s`.
* `%i`: Works the same way as `%d`.
* `%e`: The exponential representation of a number. For `uint256` and `int256` types.
* `%x`: The hexadecimal representation of a number. For `uint256` and `int256` types.
* `%o`: Object. A string representation of an object with generic JavaScript-styled object formatting. For solidity types, this basically surround the string representation of the value in single-quotes.
* `%%`: single percent sign ('%'). This does not consume an argument.
* Returns: `<string>` The formatted string

If a specifier does not have a corresponding argument, it is not replaced:

```solidity
console.log("%s:%s", "foo");
// Returns: "foo:%s"
```

Values that are not part of the format string are formatted using as a human-readable string representation.

If there are more arguments passed to the console.log() method than the number of specifiers, the extra arguments are concatenated to the returned string, separated by spaces:

```solidity
console.log("%s:%s", "foo", "bar", "baz");
// Returns: "foo:bar baz"
```

If only one argument is passed to console.log(), it is returned as it is without any formatting:

```solidity
console.log("%% %s");
// Returns: "%% %s"
```

The String format specifier (`%s`) should be used in most cases unless specific functionality is needed from other format specifiers.