表示字串（Represent String）
Octave 中的字串是指一連串使用單引號（'）或是雙引號（"）包起來的字元，字串的長度沒有特別的限制。例如：
"string 1"
'string 2'
在 Octave 中，單引號也用在矩陣的轉置運算上，而雙引號並沒有別的功能，因此為了避免混淆，建議盡量使用雙引號表示字串。
使用類似定義陣列的方式可以將多個字串連接起來，例如：
["foo", "bar", "baz"]
這會得到一個連接起來的字串 "foobarbaz"。
跳脫序列（Escape Sequences）
在雙引號的字串中，可以使用反斜線來表示一些特殊的字元，這樣的表示法統稱跳脫序列，例如 “\n” 表示換行字元，” 則表示雙引號。在單引號的字串中，反斜線不具任何特殊意義，以下示範雙引號與單引號的差異：
toascii("\n")
輸出為
ans = 10
toascii('\n')
輸出為
ans =
92 110以下是可以在雙引號中使用的跳脫序列，這些與 C 語言中所支援的跳脫序列相同：
\\：反斜線（\）。\"：雙引號（"）。\'：單引號（'）。\0：null 字元，Ctrl+@，ASCII 碼為 0。\a：alert 字元，Ctrl+g，ASCII 碼為 7。\b：backspace 字元，Ctrl+h，ASCII 碼為 8。\f：formfeed 字元，Ctrl+l，ASCII 碼為 12。\n：newline 字元，也就是換行，Ctrl+j，ASCII 碼為 10。\r：return 字元，Ctrl+m，ASCII 碼為 13。\t：horizontal tab 字元，Ctrl+i，ASCII 碼為 9。\v：vertical tab 字元，Ctrl+k，ASCII 碼為 11。
在單引號中唯一的跳脫序列就是單引號，要輸入連續兩個單引號可以代表一個單引號，例如：
'I can''t escape'
輸出為
ans = I can't escape
字元陣列（Character Arrays）
在 Octave 中的字串事實上使以陣列的方式儲存，例如 "ddddd" 這個字串在 Octave 內部是一個長度為 5 的列向量，而向量中的每個元素值皆為 100（100 是字元 d 的 ASCII 碼），由於這特性使得字串可以擴充為字元矩陣，使用字元矩陣可以表示多個長相同的字串，Octave 習慣上將每個列（row）視為一個字串，但將每個行（column）視為一個字串也是可行的。
要建立字元矩陣最簡單的方式是將多個字串直接放進矩陣中，例如：
collection = ["String #1"; "String #2"]
這樣會產生 2 乘 9 的字元矩陣。
要判斷一個矩陣是否為字元矩陣，可以使用 ischar() 函數：
ischar (a)
判斷 a 是否為字元矩陣，是則傳回 1，否則傳回 0。
而要判斷一個變數是否為字串（非字元矩陣），可以使用 ischar() 函數配合 isvector() 函數，例如：
ischar(collection)
輸出為
ans = 1
ischar(collection) && isvector(collection)
輸出為
ans = 0
ischar("my string") && isvector("my string")
輸出為
ans = 1
當使用不同長度的字串產生字元矩陣時，Octave 會將較短的字串自動加上空白字元補齊，使每個字串長度都跟最長的字串長度相等，而自動加入的字元除了空白之外，亦可以使用 string_fill_char() 函數設定：
val = string_fill_char ()
old_val = string_fill_char (new_val)
查詢或設定在建立字元陣列時，用來補齊的字元，這個值必須是單一個字元，預設是空白（" "）。例如：
old_fc = string_fill_char ("X");
[ "these"; "are"; "strings" ]
string_fill_char(old_fc);
輸出為
ans = theseXX areXXXX strings
自動補齊字串也顯示出字元陣列的限制，一個字元陣列無法表示多個不同長度的字串，若需要表示不同長度的字串，可以使用字串的巢狀陣列，請參考資料容器。
建立字串（Creating Strings）
最簡單的字串產生方法上面已經介紹過了，直接用單引號或雙引號包起來就可以了，接下來介紹一些其他的方式。
blanks (n)
blanks(n) 函數會產生由空白字元（ASCII 碼為 32）所構成的字串，參數 n 可以指定字串的長度，例如：
str = blanks(10);
whos str
輸出為
Attr Name Size Bytes Class
==== ==== ==== ===== =====
str 1x10 10 charstr 是一個長度為 10 的空白字串。
連接字串（Concatenating Strings）
上面已經示範過如何使用中括弧的方式將字串連接起來，除了這個方式之外，Octave 中也有許多函數可以處理字串接的工作，例如：char()、strvcat()、strcat() 與 cstrcat() 函數，除此之外，一般的連接函數也可以用在字串上，例如：cat()、horzcat() 與 vertcat() 等。
除了 cstrcat() 函數之外，所有的字串連接函數都可以一連串的將數值依照 ASCII 碼轉換為字串，例如：
char([98, 97, 110, 97, 110, 97])
輸出為
ans = banana
char() 與 strvcat() 函數會將多個字串以垂直的方式接起來，而 strcat() 與 cstrcat() 函數則是以水平的方式將字串連接起來，例如：
char("an apple", "two pears")
輸出為
ans = an apple two pears
strcat("oc", "tave", " is", " good", " for you")
輸出為
ans = octave is good for you
char() 函數在遇到空字串（長度為 0 的字串）時，會產生一個空的列（row），而 strvcat() 函數遇到同樣的情況則是會將空字串忽略，例如：
char("orange", "green", "", "red")
輸出為
ans = orange green red
strvcat("orange", "green", "", "red")
輸出為
ans = orange green red
除了 cstrcat() 之外的所有字串連接函數都可以接受巢狀陣列的資料（請參考資料容器），char() 與 strvcat() 函數會將巢狀陣列轉換為字串，而 strcat() 函數則是連接巢狀陣列中 cell 內的字串，例如：
char({"red", "green", "", "blue"})
輸出為
ans = red green blue
strcat({"abc"; "ghi"}, {"def"; "jkl"})
輸出為
ans =
{
[1,1] = abcdef
[2,1] = ghijkl
}strcat() 函數會將字串結尾的空白移除（除了在巢狀陣列之內的），而 cstrcat() 函數則會將結尾的空白保留，這兩個規則在不同的情況下都很有用，例如：
strcat(["dir1";"directory2"], ["/";"/"], ["file1";"file2"])
輸出為
ans = dir1/file1 directory2/file2
cstrcat(["thirteen apples"; "a banana"], [" 5$";" 1$"])
輸出為
ans = thirteen apples 5$ a banana 1$
上面這個 cstrcat() 中，空白字元來自於 Octave 自動補齊的特性，在建立字元陣列時會在較短的字串結尾自動補上的空白，請參考上面的說明。
char (x)
char (n, ...)
char (s1, s2, ...)
char (cell_array)
char() 函數可以從一個或多個數值矩陣、字元矩陣或巢狀陣列建立字元陣列，所有的參數會依照順序垂直的連接起來，並將較短的字串補齊空白後傳回，空字串的參數會被保留。若是輸入的數值，則會將數值依照 ASCII 碼轉為字元，而若是數值超出 ASCII 碼的範圍（0-255），則會產生錯誤。對於巢狀陣列，char() 會將每個元素分開處理，巢狀陣列經由 char() 所轉換的結果，在大部分的情形下可以再經由 cellstr() 函數轉換回原來的巢狀陣列。例如：
char ([97, 98, 99], "", {"98", "99", 100}, "str1", ["ha", "lf"])
strvcat (x)
strvcat (n, ...)
strvcat (s1, s2, ...)
strvcat (cell_array)
strvchar()
函數可以從一個或多個數值矩陣、字元矩陣或巢狀陣列建立字元陣列，所有的參數會依照順序垂直的連接起來，並將較短的字串補齊空白後傳回，空字串的參數會被忽略。若是輸入的數值，則會將數值依照 ASCII 碼轉為字元，而若是數值超出 ASCII 碼的範圍（0-255），則會產生錯誤。對於巢狀陣列，strvchar() 會將每個元素分開處理，巢狀陣列經由 char() 所轉換的結果，在大部分的情形下可以再經由 cellstr() 函數轉換回原來的巢狀陣列。例如：
strvcat ([97, 98, 99], "", {"98", "99", 100}, "str1", ["ha", "lf"])
strcat (s1, s2, ...)
strcat() 函數會將所有的參數以水平的方式連接起來，當輸入的參數為字串的巢狀陣列時，strcat() 會將個別的 cell 分開處理，若是輸入的參數是數值，則會依照 ASCII 碼轉換為字元。字串結尾的空白會被忽略。例如：
s = [ "ab"; "cde" ];
strcat (s, s, s)
輸出為
ans = ababab cdecdecde
s = { "ab"; "cde" };
strcat (s, s, s)
輸出為
ans =
{
[1,1] = ababab
[2,1] = cdecdecde
}strcat("abc ", "ABC")
輸出為
ans = abcABC
cstrcat (s1, s2, ...)
cstrcat() 函數會將所有的參數以水平的方式連接起來，字串結尾的空白會被保留。例如：
cstrcat ("ab ", "cd")
輸出為
ans = ab cd
s = [ "ab"; "cde" ];
cstrcat (s, s, s)
輸出為
ans = ab ab ab cdecdecde
將數值轉為字串（Conversion of Numerical Data to Strings）
要將數值轉換為字串，除了上述依照 ASCII 碼的方法之外，Octave 亦提供了其他的轉換方式與相關函數，例如 mat2str() 與 num2str() 函數可以轉換實數或複數的矩陣；int2str() 函數則可以轉換整數的矩陣，若是複數則會取其實部並轉為最接近的整數。更一般化的轉換可以使用 sprintf() 函數。
mat2str (x, n)
mat2str (..., 'class')
mat2str() 可將實數或複數的矩陣轉為字串，其傳回值適用於 eval() 函數。
參數 n 是指定數值的精確度，若 n 指定為一個純量，則實部與虛部都使用同一個精確度，若指定為向量，則 n(1) 代表實部的精確度，而 n(2) 代表虛部的精確度。若是不指定，則 n 預設為 17。例如：
mat2str ([ -1/3 + i/7; 1/3 - i/7 ], [4 2])
結果為："[-0.3333+0.14i;0.3333-0.14i]"。
mat2str ([ -1/3 +i/7; 1/3 -i/7 ], [4 2])
結果為："[-0.3333+0i,0+0.14i;0.3333+0i,-0-0.14i]"。
若是加入參數 'class'，則輸出時會加上 x 的類別，讓 eval() 函數在執行時也會得到相同類別的矩陣，例如：
mat2str (int16([1 -1]), 'class')
結果為："int16([1,-1])"。
num2str (x)
num2str (x, precision)
num2str (x, format)
num2str() 函數可將純量或陣列數值轉換為字串或字元陣列。參數 precision 是指定輸出的有效位數；參數 format 是輸出的格式，此格式與 sprintf() 函數所使用的格式相同。例如：
num2str (123.456)
結果為："123.46"。
num2str (123.456, 4)
結果為："123.5"。
s = num2str ([1, 1.34; 3, 3.56], "%5.1f")
輸出為
s = 1.0 1.3 3.0 3.6
此 s 是一個字元矩陣：
whos s
輸出為
Attr Name Size Bytes Class
==== ==== ==== ===== =====
s 2x8 16 charnum2str() 函數亦可處理複數的轉換：
num2str (1.234 + 27.3i)
結果為："1.234+27.3i"。
num2str() 函數並不是非常的有彈性，若需要更有彈性的輸出可以使用 sprintf() 函數。
num2str()函數在處理複數時，所指定的format只能包含單一個數值的格式，若是加入其他任何多餘的字元，將會導致不可預期的結果。
int2str (n)
num2str() 函數可將純量或陣列整數轉換為字串或字元陣列。例如：
int2str(123)
輸出為
ans = 123
s = int2str ([1, 2, 3; 4, 5, 6])
輸出為
s = 1 2 3 4 5 6
得到的 s 是一個字元矩陣：
whos s
輸出為
Attr Name Size Bytes Class
==== ==== ==== ===== =====
s 2x7 14 char若需要更有彈性的輸出，可以使用 sprintf() 函數。
字串比較（Comparing Strings）
因為字串是字元所構成的陣列，字串之間在比較時是將每個字元分開來進行的，例如：
GNU = "GNU’s Not UNIX";
spaces = (GNU == " ")
輸出為
spaces = 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0
若要判斷兩個字串是否相等，可以使用 strcmp() 函數，此函數會比較兩個字串是否完全相等，strncmp() 函數可以比較兩個字串的前 n 個字元是否相等，另外 strcmpi() 與 strncmpi() 的功能也類似，但這兩個函數會將大小寫的字元是為相等（case-insensitive）。
strcmp (s1, s2)
strcmp(s1, s2) 函數會判斷字串 s1 與 s2 是否完全相等，若相等則傳回 1，否則傳回 0。若 s1 或 s2 其中有一個是字串的巢狀陣列，則會傳回相同長度的陣列，而陣列中包含巢狀陣列中各個字串比對的結果，而另外一個參數可以是字串的巢狀陣列（相同長度或是長度為 1）、字元矩陣或字串。例如：
strcmp("abc", "abc")
輸出為
ans = 1
strcmp("abc", {"abc", "def"})
輸出為
ans = 1 0
strcmp({"abc", "def", "123"}, {"abc", "def", "ABC"})
輸出為
ans = 1 1 0
為了與 Matlab 相容，
strcmp()在比對結果相同時傳回1，不同時傳回0，這與 C 語言中的習慣剛好相反。
strncmp (s1, s2, n)
strncmp(s1, s2, n) 函數與 strncmp(s1, s2) 函數類似，但只比較字串 s1 與 s2 的前 n 個字元是否相等，若相等則傳回 1，否則傳回 0，例如：
strncmp("abcd", "abce", 3)
輸出為
ans = 1
若 s1 或 s2 其中有一個是字串的巢狀陣列，則會傳回相同長度的陣列，而陣列中包含巢狀陣列中各個字串比對的結果，而另外一個參數可以是字串的巢狀陣列（相同長度或是長度為 1）、字元矩陣或字串。例如：
strncmp("abc", {"abc", "abd"}, 2)
輸出為
ans = 1 1
strncmp({"abc", "def", "123"}, {"abc", "dec", "243"}, 2)
輸出為
ans = 1 1 0
strcmpi (s1, s2)
strcmpi() 函數與 strcmp() 函數類似，但比對字串時不分大小寫。
strncmpi (s1, s2, n)
strncmpi() 函數與 strncmp() 函數類似，但比對字串時不分大小寫。
validstr = validatestring (str, strarray)
validstr = validatestring (str, strarray, funcname)
validstr = validatestring (str, strarray, funcname, varname)
validstr = validatestring (..., position)
validatestring(str, strarray) 函數用來檢查字串 str 是否符合 strarray 所指定的格式：此函數會檢查字串 str 是否等於 strarray 中的任意一個字串，或是其子字串（substring），str 是要比對的字串，strarray 是字串所構成的巢狀陣列。檢查結果若是 str 符合 strarray 所指定的格式，則將結果傳回（即 validstr），若不符合則產生錯誤訊息。例如：
validatestring("abc", {"abc", "12345", "string"})
輸出為
ans = abc
若在比對時發現只有某一個字串的開頭符合，則 Octave 會自動將 strarray 中完整的字串傳回：
validatestring("abc", {"abcdef", "12345", "string"})
輸出為
ans = abcdef
字串操作（Manipulating Strings）
在 Octave 中有很多可以處理字串操作的函數，由於字串本身就是以矩陣的方式儲存，因此可以使用一般的運算子進行簡單的字串操作，下面的範例說明如何將字串中的空白字元替換成下底線：
quote = "First things first, but not necessarily in that order";
quote( quote == " " ) = "_"
輸出為
quote = First_things_first,_but_not_necessarily_in_that_order
對於較複雜的字串操作，例如搜尋、取代與常規表示法可以使用下面的函數：
deblank (s)
deblank(s) 函數會移除字串 s 結尾處的空白與 null 字元，若 s 為字元陣列，則會將每一列（row）結尾的共同空白移除，若 s 為字串的巢狀陣列，則 deblank() 函數會以遞迴的方式，將巢狀陣列中的每一個字串結尾處的空白都移除。例如：
s = "string ";
s2 = deblank(s);
whos s s2
輸出為
Attr Name Size Bytes Class
==== ==== ==== ===== =====
s 1x8 8 char
s2 1x6 6 char字元陣列的範例：
m = ["ab "; "12345 "; "xyz "];
m2 = deblank(m);
whos m m2
輸出為
Attr Name Size Bytes Class
==== ==== ==== ===== =====
m 3x7 21 char
m2 3x5 15 char字元矩陣 m 是一個 3 乘 7 的矩陣，三個列的結尾都有共同的兩個空白字元，因此 deblank() 函數會移除每一列的最後兩個空白，最後得到的 m2 為 3 乘 5 的字元矩陣。
巢狀陣列的範例：
a = {"ABC ", "12 "};
b = deblank(a);
whos a{1} a{2} b{1} b{2}
輸出為
Attr Name Size Bytes Class
==== ==== ==== ===== =====
a{1} 1x5 5 char
a{2} 1x3 3 char
b{1} 1x3 3 char
b{2} 1x2 2 charstrtrim (s)
strtrim(s) 函數會移除字串 s 開頭與結尾處的空白與 null 字元，若 s 為字元矩陣，則會將每一列（row）開頭與結尾處的共同空白移除，若 s 為字串的巢狀陣列，則 strtrim() 函數會以遞迴的方式，將巢狀陣列中的每一個字串開頭與結尾處的空白都移除。例如：
strtrim (" abc ")
輸出為
ans = abc
strtrim ([" abc "; " def "])
輸出為
ans = abc def
strtrunc (s, n)
strtrunc(s, n) 函數會擷取字串 s 的開頭前 n 個字元，若 s 為字元矩陣，則擷取開頭的前 n 個行（column）；若 s 為字串的巢狀陣列，則 strtrunc() 函數會擷取巢狀陣列中每一個自串的開頭前 n 個字元，並傳回新的巢狀陣列。
findstr (s, t, overlap)
findstr(s, t) 函數可搜尋 s 與 t 兩個字串之中較短的字串在較長字串中出現的位置，例如：
findstr ("ababab", "a")
輸出為
ans = 1 3 5
也可以寫成這樣
findstr ("a", "ababab")
輸出為
ans = 1 3 5
若將 overlap 參數設為 0，則輸出的位置就不會重複：
findstr ("abababa", "aba", 0)
輸出為
ans = 1 5
若不設定 overlap 參數，則預設會輸出重複的位置，例如：
findstr ("abababa", "aba")
輸出為
ans = 1 3 5
idx = strchr (str, chrs)
idx = strchr (str, chrs, n)
idx = strchr (str, chrs, n, direction)
strchr() 函數與 find() 函數類似，strchr(str, chars) 函數會搜尋字串 chars 中所指定的字元出現在字串 str 中的位置，例如：
strchr("abcd1234abcd", "b3")
輸出為
ans =
2 7 10這會傳回字串 "abcd1234abcd" 中所有出現字元 "b" 或 "3" 的位置。
參數 n 是限制最多搜尋的個數，參數 direction 是尋找的方向，可以設定為 "first" （從開頭開始向後搜尋）或 "last"（從結尾開始像前搜尋），例如：
strchr("abcd1234abcd", "b3", 2, "last")
輸出為
ans =
7 10
strchr()函數的搜尋速度在大部分的情況會比常規表示法函數快。
index (s, t)
index (s, t, direction)
index(s, t) 函數會傳回字串 s 中第一個出現字串 t 的位置，若字串 s 中沒有出現字串 t 則傳回 0，例如：
index ("Teststring", "t")
輸出為
ans = 4
參數 direction 是指定搜尋方向，若指定為 "first" 則傳回第一個出現的位置，若指定為 "last" 則傳回最後一個出現的位置。
index()函數不適用於字串陣列或是字元矩陣。
rindex (s, t)
rindex(s, t) 函數會傳回字串 s 中最後一個出現字串 t 的位置，若字串 s 中沒有出現字串 t 則傳回 0，此函數之功用等同於 index() 將 direction 參數設為 "last"。例如：
rindex ("Teststring", "t")
輸出為
ans = 6
rindex()函數不適用於字串陣列或是字元矩陣。
strfind (str, pattern)
strfind (cellstr, pattern, direction)
strfind(str, pattern) 函數會搜尋 pattern 在字串 str 中出現的位置，若沒有出現或 pattern 的長度比 str 的長度長，則傳回空陣列 []。若 str 指定為字串的巢狀陣列，則傳回值為向量的巢狀陣列。例如：
strfind ("abababa", "aba")
輸出為
ans = 1 3 5
strfind ({"abababa", "bebebe", "ab"}, "aba")
輸出為
ans =
{
[1,1] =
1 3 5
[1,2] = [](1x0)
[1,3] = [](1x0)
}strmatch (s, a, "exact")
strmatch(s, a) 函數傳回在 a 中出現字串 s 的元素索引，其傳回值是一個行向量，參數 a 為字元矩陣或字串的巢狀陣列。若沒有設定 "exact" 參數，則只比對開頭是否與 s 相同。null 字元會比對空白字元。例如：
strmatch ("apple", "apple juice")
輸出為
ans = 1
strmatch ("apple", ["apple pie"; "apple juice"; "an apple"])
輸出為
ans = 1 2
strmatch ("apple", {"apple pie"; "apple juice"; "tomato"})
輸出為
ans = 1 2
[tok, rem] = strtok (str, delim)
strtok(str, delim) 函數會找出 delim 之中的字元在字串 str 中第一個出現的位置，並將此字元之前的字串傳回（不包含此字元），若是有設定輸出參數 rem，則 rem 中會包含此字元之後的字串（包含此字元）。若是字串的第一個字元就在 delim 之中，則第一個字元會被忽略。若不指定 delim 則預設為空白字元。例如：
strtok ("this is the life")
輸出為
ans = this
[tok, rem] = strtok ("14*27+31", "+-*/")
輸出為
tok = 14 rem = *27+31
[s] = strsplit (p, sep, strip_empty)
strsplit(p, sep, strip_empty) 函數會以 sep 中的字元做為分隔字元，將字串 p 切成字串的巢狀陣列，字串 p 中若包含連續或位於字串兩端的分隔字元會使結果中產生空字串，若要將空字串移除，可指定 strip_empty 參數為 true，若不指定預設為 false。例如：
strsplit("this is the life", " ")
輸出為
ans =
{
[1,1] = this
[1,2] = is
[1,3] = the
[1,4] = life
}strrep (s, x, y)
strrep(s, x, y) 函數會將字串 s 中所有出現字串 x 的地方都替換成字串 y，並傳回替換後的結過，例如：
strrep ("This is a test string", "is", "&%$")
輸出為
ans = Th&%$ &%$ a test string
substr (s, offset, len)
substr(s, offset, len) 函數傳回 s 字串的子字串，此子字串從 s 字串的第 offset 字元開始往後算起，長度為 len。若 offset 指定為負數，則開始的位置變成從 s 字串的結尾往前算。若不指定 len 參數，則傳回的子字串會取至 s 字串的結尾。例如：
substr ("This is a test string", 6, 9)
輸出為
ans = is a test
[s, e, te, m, t, nm] = regexp (str, pat)
[...] = regexp (str, pat, opts, ...)
regexp() 函數使用常規表示法（regular expression）進行字串的比對，在字串 str 中比對由 pat 所指定的常規表示法，並傳回符合的字串及其位置，若是找不到符合的字串則傳回空向量，pat 中可以使用任何標準的常規表示法，包含：
.：比對任意字元。* + ? {}重複運算子（Repetition operators）：*：比對 0 次以上。+：比對 1 次以上。?：比對 0 次或 1 次。{}：指定比對的次數，{n}為剛好比對n次，{m,}為比對m次以上，{m,n}為比對m次到n次。
[...] [^...]：列舉運算子（List operators），例如[ab]c為比對ac或bc。()：群組運算子（Grouping operator）。|：多重選擇運算子（Alternation operator），比對其中一種常規表示法，此運算子必須配合上述的群組運算子使用。^ $：定位運算子（Anchoring operator），^比對字串str的開頭，$比對字串str的結尾。
下列的跳脫字元（escaped character）表示各種特殊意義，在使用這些跳脫字元時，建議使用單引號將常規表示法 pat 包起來，而不要使用雙引號，這樣可以避免這些跳說字元在傳給 regexp() 函數時就被 Octave 解析成其他的字元。
\b：比對字（word）的邊界。\B：比對除了字邊界以外的地方。\w：比對英文字字元。\W：比對\w以外的字元。\<：比對字（word）的開頭。\>：比對字（word）的結尾。\s：比對空白、Tab 等字元。\S：比對\s以外的字元。\d：比對數字。\D：比對\d以外的字元。
regexp() 函數的傳回值預設是依照下面的順序傳回：
s：每一個符合的子字串起始索引值。e：每一個符合的子字串結尾索引值。te：包含所有在pat中被群組運算子()包起來的區段索引。m：一個巢狀陣列，包含所有比對符合的內容。t：一個巢狀陣列，包含所有在pat中被群組運算子()包起來的區段內容。nm：一個資料結構（structure），包含所有被具名的群組運算子()包起來的區段內容，一個名稱為name的群組運算子為(?...)。
regexp() 函數的傳回值格式可以藉由 opts 參數設定，可以指定傳回值與傳回的順序，可以用的選項有：
'start'：指定s。'end'：指定e。'tokenExtents'：指定te。'match'：指定m。'token'：指定t。'names'：指定nm。
regexp() 函數還有一些額外的參數：
'once'：只傳回第一個比對成功的結果。'matchcase'：將英文大小寫視為不同。'ignorecase'：將英文大小寫視為相同。'stringanchors'：設定定位運算子比對整個字串的開頭與結尾。'lineanchors'：設定定位運算子比對行（line）的開頭與結尾。'dotall'：設定句點.可比對任意字元，包含換行字元。'dotexceptnewline'：設定句點.可比對除了換行字元之外的任意字元。'freespacing'：將pat中#符號之後的所有內容或空白視為註解。'literalspacing'：將在pat中的所有#符號視為一般字元來比對。
[s, e, te, m, t, nm] = regexpi (str, pat)
[...] = regexpi (str, pat, opts, ...)
regexpi() 函數與 regexp() 函數類似，但此函數將英文大小寫視為相同。
string = regexprep (str, pattern, repstr, options)
regexprep(str, pattern, repstr, options) 函數會以常規表示法 pattern 比對字串 str，並將比對符合的部分以 repstr 取代。repstr 中亦可以使用 $i 表示在 pattern 中第 i 個以括弧包起來的部分，例如：
regexprep("Bill Dunn", '(\w+) (\w+)', '$2, $1')
輸出為
ans = Dunn, Bill
參數 options 部分可以使用的有：
'once'：只替換第一個比對成功的結果。'warnings'：這個參數是為了相容性而設置的，並沒有作用。'ignorecase'與'matchcase'：設定是否將英文大小寫視為相同，亦可在pattern中以(?i)與(?-i)指定。'lineanchors'與'stringanchors'：設定定位運算子比對行（line）的開頭與結尾，或是比對整個字串的開頭與結尾，亦可在pattern中以(?m)與(?-m)指定。'dotexceptnewline'與'dotall'：設定句點 . 是否比對換行字元，亦可在pattern中以(?s)與(?-s)指定。'freespacing'與'literalspacing'：設定#與空白是否可用於pattern中做為註解，亦可在pattern中以(?x)與(?-x)指定。
例如：
regexprep("ABC\nabc\nAbc", "^ab", "XY", 'ignorecase', 'lineanchors')
輸出為
ans = XYC XYc XYc
regexptranslate (op, s)
regexptranslate(op, s) 函數會將字串 s 轉換為常規表示法中使用的格式，參數 op 是指定轉換的類型，可用的選項有：
"wildcard"：將 wildcard 字元轉換為常規表示法，例如*與?等。"escape"：將跳脫字元轉換為常規表示法，例如$ . ? []等。
下面是一些範例：
regexptranslate ("wildcard", "*.m")
輸出為
ans = .*\.m
regexptranslate ("escape", "12.5")
輸出為
ans = 12\.5
字串轉換（String Conversions）
Octave 中有許多字串與數值間的轉換函數，例如可以將函有十六進位數字的字串轉換為浮點數：
hex2dec("FF")
輸出為
ans = 255
bin2dec (s)
bin2dec(s) 函數會將字串 s 中的二進位數字轉為十進位的數值後傳回，例如：
bin2dec("1110")
輸出為
ans = 14
若 s 為字元矩陣，則會分別將 s 的每一列（row）各轉為一個十進位數值，產生一個行（column）向量並傳回，若有無法轉換的內容，則會產生 NaN。例如：
bin2dec(["1110"; "101001"])
ans = 14 41
dec2bin (n, len)
dec2bin(n) 函數會將非負的數值 n 轉換為二進位的數字所構成的字串，例如：
dec2bin(14)
輸出為
ans = 1110
若 n 為一個向量，則會將向量中的每一個數值個別轉換為二進位的數字所構成的字元矩陣，矩陣中每一個列（row）對應到向量中的每一個數值，而長度較短的列會在開頭補上 0，讓所有的列都有相同的長度，例如：
dec2bin([6, 3, 98])
ans = 0000110 0000011 1100010
參數 len 是指定轉換出來的字串的最大長度。
dec2hex (n, len)
dec2hex(n) 函數會將非負的數值 n 轉換為十六進位的數字所構成的字串，例如：
dec2hex(2748)
輸出為
ans = ABC
若 n 為一個向量，則會將向量中的每一個數值個別轉換為十六進位的數字所構成的字元矩陣，矩陣中每一個列（row）對應到向量中的每一個數值，而長度較短的列會在開頭補上 0，讓所有的列都有相同的長度，例如：
dec2hex([62, 31, 8987])
輸出為
ans = 003E 001F 231B
參數 len 是指定轉換出來的字串的最大長度。
hex2dec (s)
hex2dec(s) 函數會將非負的數值 n 轉換為十六進位的數字所構成的字串，例如：
hex2dec ("12B")
輸出為
ans = 299
hex2dec ("12b")
輸出為
ans = 299
若 s 為字元矩陣，則會分別將 s 的每一列（row）各轉為一個十進位數值，產生一個行（column）向量並傳回，若有無法轉換的內容，則會產生 NaN。例如：
hex2dec (["12b"; "abcd"])
ans =
299
43981dec2base (n, b, len)
dec2base(n, b) 函數會將非負的整數 n 轉換為 b 進位的數字的字串，例如：
dec2base(123, 3)
輸出為
ans = 11120
若 n 為一個向量，則會將向量中的每一個數值個別轉換為 b 進位的數字所構成的字元矩陣，矩陣中每一個列（row）對應到向量中的每一個數值，而長度較短的列會在開頭補上 0，讓所有的列都有相同的長度，例如：
dec2base([62, 31, 8987], 3)
輸出為
ans = 000002022 000001011 110022212
若 b 為一個字串，則 b 中的字元會被用來表示數字（空白字元無法使用），例如：
dec2base(123, "aei")
輸出為
ans = eeeia
參數 len 是指定轉換出來的字串的最大長度。
base2dec (s, b)
bin2dec(s) 函數會將字串 s 中的 b 進位數字轉為十進位的數值後傳回，例如：
base2dec("11120", 3)
輸出為
ans = 123
若 s 為字元矩陣，則會分別將 s 的每一列（row）各轉為一個 b 進位數值，產生一個行（column）向量並傳回，若有無法轉換的內容，則會產生 NaN。每一列在轉換前會先將內容靠右對齊，因此結尾的空白會被忽略。例如：
base2dec(["000002022"; "000001011"; "110022212"], 3)
輸出為
ans =
62
31
8987若 b 為字串，則會使用 b 中的字元來解析數值（空白字元無法使用），例如：
base2dec("yyyzx", "xyz")
輸出為
ans = 123
s = num2hex (n)
num2hex(n) 函數會將雙精度浮點數的純量或陣列 n 轉換為 IEEE 754 標準的十六進位數字所構成的字串，此字串的長度為 16 個字元，例如：
num2hex ([-1, 1, e, Inf, NaN, NA])
輸出為
ans = bff0000000000000 3ff0000000000000 4005bf0a8b145769 7ff0000000000000 7ff8000000000000 7ff840f440000000
n = hex2num (s)
hex2num(s) 函數會將 IEEE 754 標準的十六進位數字所構成的字串轉換為雙精度浮點數，若輸入的字串長度小於 16，則 Octave 會自動在字串後方以 '0' 補齊 16 個字元。
hex2num ("4024000000000000")
輸出為
ans = 10
hex2num ("4024")
輸出為
ans = 10
若 s 為字元矩陣，則會將每個列（row）個別轉換為雙精度浮點數，傳回一個行（column）向量，例如：
hex2num (["4005bf0a8b145769";"4024000000000000"])
輸出為
ans =
2.7183
10.0000[num, status, strarray] = str2double (str, cdelim, rdelim, ddelim)
str2double(str) 函數會將字串 str 轉換為數值，其可接受的格式為 [+-]d[.]dd[[eE][+-]ddd] 其中 d 代表數字 0-9，中括弧包起來的部份是選擇性的（可有可無）。
傳回值的 num 是轉換出來的數值資料，若轉換失敗（例如傳入的字串格式不正確時）則 status 會設為 -1，而 num 會設為 NaN。傳回值 status 在轉換成功時會被設為 0，否則會被設為 -1。
strarray 是一個字串的巢狀陣列。
若 str 是一個字元陣列或是字串的巢狀陣列，則 num 與 status 會傳回對應大小的矩陣。str 亦可以包含多個元素，各元素之間以行與列的分隔符號（cdelim 與 rdelim）分隔。
cdelim 為行（column）的分隔符號，預設為 Tab、空白（Space）與逗號（Comma）（ASCII 碼為 9、32 與 44）；rdelim 為列（row）的分隔符號，預設為 newline、carriage return 與 semicolon（ASCII 碼為 10、13 與 59）；ddelim 為數字的分隔符號（decimal delimiter），預設為句點（.）（ASCII 碼為 46）。cdelim、rdelim 與 ddelim 可以使用的字原有：null、newline、carriage return、semicolon、colon、slash、tab、space、comma 或 '()[]{}'（ASCII 碼為 0, 9, 10, 11, 12, 13, 14, 32, 33, 34, 40, 41, 44, 47, 58, 59, 91, 93, 123, 124, 125）
以下是一些範例：
str2double ("-.1e-5")
輸出為
ans = -1.0000e-06
str2double (".314e1, 44.44e-1, .7; -1e+1")
輸出為
ans =
3.14000 4.44400 0.70000
-10.00000 NaN NaNline = "200, 300, NaN, -inf, yes, no, 999, maybe, NaN";
[x, status] = str2double (line)
輸出為
x = 200 300 NaN -Inf NaN NaN 999 NaN NaN status = 0 0 0 0 -1 -1 0 -1 0
str2double()函數與str2num()函數功能類似，但str2double()函數不是使用eval的方式進行轉換，因此無法處理未知的數值格式。
strjust (s, align)
strjust(s, align) 函數會將字串 s 依照參數 align 所指定的方式對齊字串，參數 align 可用的選項有 "left"、"center" 與 "right"，若沒有指定 align 參數則預設為 "right"。若 s 為字串陣列，則會對齊陣列中每一個字串。字串中的 null 字元會被替換成空白字元。例如：
strjust (["a"; "ab"; "abc"; "abcd"])
輸出為
ans = a ab abc abcd
str2num (s)
str2num(s) 函數會將字串 s 轉換為數值，若 s 為字元陣列則轉換結果為數值陣列，例如：
str2num("3.141596")
輸出為
ans = 3.1416
str2num(["1, 2, 3"; "4, 5, 6"])
輸出為
ans = 1 2 3 4 5 6
str2num()函數在轉換時是使用eval()函數做轉換，因此在s中所有的程式碼都會被執行，若要避免執行s之中的程式碼，可以使用str2double()替代 。
toascii (s)
toascii(s) 函數會將字串 s 轉換為 ASCII 碼，例如：
toascii ("ASCII")
輸出為
ans = 65 83 67 73 73
tolower (s)
lower (s)
tolower(s) 與 lower(s) 函數會將字串 s 中的大寫字母轉換為小寫字母，其餘的字元保持不變，例如：
tolower ("MiXeD cAsE 123")
輸出為
ans = mixed case 123
toupper (s)
upper (s)
toupper(s) 與 upper(s) 函數會將字串 s 中的小寫字母轉換為大寫字母，其餘的字元保持不變，例如：
toupper ("MiXeD cAsE 123")
輸出為
ans = MIXED CASE 123
do_string_escapes (string)
do_string_escapes(string) 函數會將字串 string 中的跳脫字元轉為對應的特殊字元，例如：
string = 'abc\ndef';
do_string_escapes(string)
輸出為
ans = abc def
undo_string_escapes (s)
undo_string_escapes(s) 函數會將字串 s 中的特殊字元轉換為跳脫字元，例如：
bell = "\a";
bell 是一個 alert 字元（Ctrl + g，ASCII 碼為 7），此字元在一般終端機輸出時會產生響鈴，有時候我們會需要輸出原本的跳脫字元：
undo_string_escapes (bell)
輸出為
ans = \a
這樣會將無法顯示在螢幕上的特殊字元以跳脫字元的方式顯示。
字元類別函數（Character Class Functions）
Octave 中提供了字元類別測試函數，這些函數類似 C 語言標準函式庫中的函數，但 Octave 所提供的函數可以接受字串陣列並傳回包含 0 或 1 的矩陣，1 代表在字串陣列中對應的字元測試結果為 true，`` 則代表 false，例如：
isalpha ("!Q@WERT^Y&")
輸出為
ans = 0 1 0 1 1 1 1 0 1 0
isalnum (s)
isalnum(s) 判斷字串 s 是否為字母或數字。
isalpha (s)
isletter (s)
判斷字串 s 是否為字母（letter）。
isascii (s)
isascii(s) 函數會判斷字串 s 是否為 ASCII 字元（ASCII 碼介於 0 至 127）。
iscntrl (s)
iscntrl(s) 函數會判斷字串 s 是否為控制字元（control character）。
isdigit (s)
isdigit(s) 函數會判斷字串 s 是否為數字（digit）。
isgraph (s)
isgraph(s) 函數會判斷字串 s 是否為可顯示字元（printable character，不包含空白字元）。
isletter (s)
isletter(s) 函數會判斷字串 s 是否為字母（letter）。
islower (s)
islower(s) 函數會判斷字串 s 是否為小寫字母。
isprint (s)
isprint(s) 函數會判斷字串 s 是否為可顯示字元（printable character，包含空白字元）。
ispunct (s)
ispunct(s) 函數會判斷字串 s 是否為 punctuation character。
isspace (s)
isspace(s) 函數會判斷字串 s 是否為空白（包含 space、 formfeed、 newline、 carriage return、 tab 與 vertical tab）。
isupper (s)
isupper(s) 函數會判斷字串 s 是否為大寫字母。
isxdigit (s)
isxdigit(s) 函數會判斷字串 s 是否為十六進位的數字（hexadecimal digit）。
isstrprop (str, pred)
isstrprop(str, pred) 函數可以測試字串 str 的屬性，參數 pred 可指定屬性，例如：
isstrprop ("abc123", "alpha")
輸出為
ans = 1 1 1 0 0 0
若 str 為一個巢狀陣列，則會以遞迴的方式對每個元素測試。以下是參數 pred 可用的選項：
"alpha"：字母（letter）。"alnum"、"alphanum"：字母或數字。"ascii"：ASCII 字元（ASCII 碼介於 0 至 127）。"cntrl"：控制字元（control character）。"digit"：數字（digit）。"graph"、"graphic"：可顯示字元（printable character，不包含空白字元）。"lower"：小寫字母。"print"：可顯示字元（printable character，包含空白字元）。"punct"：punctuation character。"space"、"wspace"：空白（包含 space、 formfeed、 newline、 carriage return、 tab 與 vertical tab）。"upper"：大寫字母。"xdigit"：十六進位的數字（hexadecimal digit）。