Not logged in

Pike has a large number of operations that you can do with strings. Some of them are expressed with operators such as + and -, and some are expressed as functions or methods that you call from your program. We will start by looking at the indexing operator, [], and then the rest of the operators.

Here is a list of some operators that you can use with strings.

  • Comparing strings

    string1 == string2 returns 1 if string1 and string2 are the same string, otherwise 0. Since strings are shared, strings that look exactly the same are the same string.

    You can also use the operator !=, which means "not same". The relational operators (<, >, etc) do work with strings. The will use lexical order, i. e. the same order that the strings would stand in a dictionary, if that dictionary considered all the characters, including blanks etc.

    For example, "foo" would stand before "fum", and is therefore smaller. As another example, "foo" would stand before "foobar".

  • Concatenation

    string1 + string2 returns a new string with string1 and string2 concatenated.

    "Foo" + "Bar" gives the result "FooBar".

  • Remove substrings

    string1 - string2 returns a new string where all occurrences of string2 have been remove from string1.

    "FooBarFoofooFum" - "Foo" gives the result "BarfooFum".

    Mathematically inclined programmers may want to note that for strings, it is not (necessarily) true that a+b-b equals a.

  • Concatenation of string literals

    String literals, which are strings within double quotes that are written in a program, can be concatenated by just putting them after each other:

    write("Hello" " " "world!" + "\n");
  • Indexing a character

    To accessing individual characters inside a string, you use the same indexing operator as for arrays: string[position].

    There is no data type for characters in Pike, so when you extract or insert a character in a string, you really work with the character code of that character. The character code is an integer. But you don't need to look up character codes in a table. You can use character literals, such as 'b'. The character literal 'b' will be translated internally in Pike to 98, which happens to the character code for the character b. (Or something else, if you use a different character set than ISO-8859-1 aka ISO Latin 1, but you almost certainly don't.)

    You can use negative indices, just as with arrays: string[-1] means the last character in the string string, string[-2] the next-to-last character, and so on.

  • Taking a range

    string[from..to] returns a new string, containing the characters at the index from up to and including the index to.

    ({ 1, 7, 3, 3, 7 }) [ 1..3 ] gives the result ({ 7, 3, 3 }).

    The form string[from..] will give the characters starting at index from and to the end of the string. The form string[..to] will give the characters from the start of the string, up to and including index to.

  • Division
    string / delimiter

    This will split the string string into an array of strings, using occurrences of the string delimiter as places to cut.

    "abcdfoofoo x" / "foo" gives the result ({ "abcd", "", " x" })

    An alternative is to divide with an integer, which will split the string into strings of the length given by that integer. Extra characters are thrown away:

    "abcdfoofoo x" / 5 gives the result ({ "abcdf", "oofoo" }).

    If you divide with the same integer, converted to a floating-point number, the extra characters will not be thrown away:

    "abcdfoofoo x" / 5.0 gives the result ({ "abcdf", "oofoo", " x" }).

  • Modulo
    string % integer

    This gives the extra characters that would be ignored in the division operation string / integer:

    "abcdfoofoo x" % 5 gives the result " x".

  • Multiplication
    array * delimiter

    This will create a new string by concatenating all the strings in the array array, with the string delimiter between them:

    ({ "7", "1", "foo" }) * ":" gives the result "7:1:foo".