What is the optimal way to define a global constant string in C++20?

Note, char[] str1 = "foo" is not a string. constexpr std::string str2 = "foo" is not a constant expression if a string is longer than some limit.

As always, the best choice depends on usages. If you going to pass those strings to a C API, then the first one is the only option.

I am asking this question for a project that uses only C++20, with no previous versions of C++ or C.

There is no best, personally I often use constexpr std::string_view str2{"foo"}; since std::string isn't constexpr in anything before C++20 (and we do have pre C++20 code). I don't use const char* to avoid "pointer" like types in C++

Your other option is C++ extern. I has it's heritage in C, but allows a global declaration in one source (translation unit) to be used throughout your project. (language linkage) Note the limitations Storage class specifiers

There is no best solution. The intuitive way is std::string_view. I always recommend using std::literals, because then you can simply write: auto str="str"sz; with deferred type deduction. If the constants are organized as an array:

using std::literals;
constexpr static std::array str_arr {
    "str 0"sv,
    "str 1"sv,
    "str 2"sv
};

Depending on the code and compiler this may increase your binary size by a few bytes. If that matters, then you need to define a string_list class of your own, with constexpr constructor, and desired properties.

std::string may be more efficient iff the string constants are short(less than 16 bytes in size). But there's unfortunately no std function that tells the short string maximum size. But if you can confirm the shortness criteria, then UDLs make code simpler to write again:

using std::literals;
constexpr static std::array str_arr {
    "str 0"s,
    "str 1"s,
    "str 2"s

I never recommend raw character arrays as string literals in C++. Aside from the decay problems associated with all raw arrays, raw character arrays have ambiguous usage; null-terminated string vs array of character values. This ambiguity may result in unpleasant surprises. Therefore, I always encourage using UDLs; sv for string_view and s for std::string. If you need arrays, std::array is available. Don't use the ambiguous raw character array literals, unless initializing an array like: std::array{"array ends in null"}.

A static constant array of characters can be placed in the Read-Only section of your executable. The array doesn't need to be created at runtime. Embedded systems can reference the data directly, no need to make copies.

Do you want to expose the fact that the string ends with \0?