Should I use 'bytes' or 'string' always?

Question

So after my understandings, bytes and strings are basically doing the same just in different formats and using bytes is cheaper -leading to my question, should I then only use string for data that is longer than 32 bytes and specify byte type for anything below?

Answer 1

According to Solidity documentation:

As a rule of thumb, use bytes for arbitrary-length raw byte data and string for arbitrary-length string (UTF-8) data. If you can limit the length to a certain number of bytes, always use one of bytes1 to bytes32 because they are much cheaper.

Variables of type bytes and string are special arrays. A bytes is similar to byte[], but it is packed tightly in calldata. string is equal to bytes but does not allow length or index access (for now).

So yes, whenever you can, you should use bytes32 as opposed to string, as long as you are certain such data won't be longer than 32 characters.

Answer 2

Just to add to the reasons given here, string can't be passed between contracts, so I incline to forcing clients to pack/unpack bytes32 and use it in place of string wherever possible.

This doesn't work.

pragma solidity ^0.4.15;

contract Str {

    event LogX(string thing);

    function x(string something) public returns(string success) {
        LogX(something);
        return something;
    }
}

contract Try {

    Str s;

    function Try(string that) {
        s = new Str();
        string set = s.x(that); // <== string can't be communicated between contracts
    }
}

Hope it helps.