所有字符串的最后一个字符，都是`\0`

```c++
// 声明了一个10个成员的字符数组，可以当作字符串。
// 由于必须留一个位置给\0，所以最多只能容纳9个字符的字符串。
char localString[10];

// C 语言提供了一种简写法，双引号之中的字符，会被自动视为字符数组。
// 不用自己添加结尾字符\0，C 语言会自动添加
{'H', 'e', 'l', 'l', 'o', '\0'}
// 等价于
"Hello"


char greeting[50] = "Hello, ""how are you ""today!";
// 等同于
char greeting[50] = "Hello, how are you today!";
// 等同于
char greeting[50] = "Hello, "
  "how are you "
  "today!";

// 使用占位符%s输出字符串。
printf("%s\n", "hello world")
```

## 字符串变量的声明

```c++
// 写法一
char s[14] = "Hello, world!";
char s[] = "Hello, world!"; // 省略字符数组的长度

// 写法二
char* s = "Hello, world!";
const char* s = "Hello, world!";
```

- 指针指向的字符串，在 C 语言内部被当作常量，不能修改字符串本身。

```c++
char* s = "Hello, world!";
s[0] = 'z'; // 错误

char s[] = "Hello, world!";
s[0] = 'z';
```

- 指针变量可以指向其它字符串。
- 但是，字符数组变量不能指向另一个字符串。
- 编译器一旦为数组变量分配地址后，这个地址就绑定这个数组变量了，这种绑定关系是不变的。
- 想要重新赋值，必须使用 C 语言原生提供的`strcpy()`函数，通过字符串拷贝完成赋值。

```c++
char* s = "hello";
s = "world";

char s[] = "hello";
s = "world"; // 报错

char s[10];
s = "abc"; // 错误

char s[10];
strcpy(s, "abc");
```

## 相关函数

### `strlen()`

```c++
// strlen()函数返回字符串的字节长度，不包括末尾的空字符\0。该函数的原型如下。
// string.h
size_t strlen(const char* s);


// 返回的是size_t类型的无符号整数，除非是极长的字符串，一般情况下当作int类型处理即可。
char* str = "hello";
int len = strlen(str); // 5
```

```c++
#include <stdio.h>
#include <string.h>
int main(void) {
  char* s = "Hello, world!";
  printf("The string is %zd characters long.\n", strlen(s));
}
```

```c++
char s[50] = "hello";
printf("%d\n", strlen(s));  // 5
printf("%d\n", sizeof(s));  // 50
```

```c++
// 自己计算字符串长度。
int my_strlen(char *s) {
  int count = 0;
  while (s[count] != '\0')
    count++;
  return count;
}
```

### `strcpy()`

```c++
char str1[10];
char str2[10];
str1 = "abc"; // 报错
str2 = str1;  // 报错


// 结果是两个指针变量s1和s2指向同一字符串，而不是将字符串s1的内容复制给s2
char* s1;
char* s2;
s1 = "abc";
s2 = s1;
```

```c++
// string.h
// 必须要保证第一个参数的长度不小于第二个参数，
// 否则虽然不会报错，但会溢出第一个字符串变量的边界，发生难以预料的结果。
// 第二个参数的const说明符，表示这个函数不会修改第二个字符串。
strcpy(char dest[], const char source[])
```

```c++
#include <stdio.h>
#include <string.h>

int main(void) {
  char s[] = "Hello, world!";
  char t[100];

  strcpy(t, s);

  t[0] = 'z';
  printf("%s\n", s);  // "Hello, world!"
  printf("%s\n", t);  // "zello, world!"
}
```

`strcpy()`的返回值是一个字符串指针（即`char*`），指向第一个参数。

```c++
char* s1 = "beast";
char s2[40] = "Be the best that you can be.";
char* ps;

// 从s2的第7个位置开始拷贝字符串beast，前面的位置不变
// s2后面的内容都被截去了，因为会连beast结尾的空字符一起拷贝
ps = strcpy(s2 + 7, s1);

puts(s2); // Be the beast
puts(ps); // beast
```

```c++
// 连续为多个字符数组赋值。
strcpy(str1, strcpy(str2, "abcd"));
```

```c++
// 自己实现字符串的拷贝
char* strcpy(char* dest, const char* source) {
  char* ptr = dest;
  // 依次将source的每个字符赋值给dest，然后移向下一个位置，直到遇到\0
  // *dest++这个表达式等同于*(dest++)，即先返回dest这个地址，再进行自增运算移向下一个位置，
  // 而*dest可以对当前位置赋值。
  while (*dest++ = *source++);
  return ptr;
}

int main(void) {
  char str[25];
  strcpy(str, "hello world");
  printf("%s\n", str);
  return 0;
}
```

### `strncpy()`

```c++
strncpy(str1, str2, sizeof(str1) - 1);
str1[sizeof(str1) - 1] = '\0'; // strncpy()不会自己添加\0
```

### `strcat()`

```c++
// string.h
// 函数会改变第一个字符串，但是第二个字符串不变
char* strcat(char* s1, const char* s2);
```

```c++
char s1[12] = "hello";
char s2[6] = "world";

strcat(s1, s2);
puts(s1); // "helloworld"
```

### `strncat()`

```c++
char* strncat(
  const char* dest,
  const char* src,
  size_t n
);
```

```c++
// strncat()总是会在拼接结果的结尾，自动添加空字符\0
// 通常会写成下面这样
strncat(
  str1,
  str2,
  sizeof(str1) - strlen(str1) - 1
);
```

### `strcmp()`

`strcmp()`只用来比较字符串，不用来比较字符。
因为字符就是小整数，直接用相等运算符（`==`）就能比较。

```c++
// s1 = Happy New Year
// s2 = Happy New Year
// s3 = Happy Holidays

strcmp(s1, s2) // 0
strcmp(s1, s3) // 大于 0
strcmp(s3, s1) // 小于 0
```

### `strncmp()`

```c++
char s1[12] = "hello world";
char s2[12] = "hello C";

if (strncmp(s1, s2, 5) == 0) {
  printf("They all have hello.\n");
}
```

### `sprintf()`，`snprintf()`

用于将数据写入字符串，而不是输出到显示器。

```c++
int sprintf(char* s, const char* format, ...);
int snprintf(char*s, size_t n, const char* format, ...);
```

```c++
char first[6] = "hello";
char last[6] = "world";
char s[40];

sprintf(s, "%s %s", first, last);
printf("%s\n", s); // hello world
```

```c++
// 表示写入字符串的最大长度不超过12（包括尾部的空字符）
snprintf(s, 12, "%s %s", "hello", "world");
```

## 字符串数组

```c++
char weekdays[7][10] = {
  "Monday",
  "Tuesday",
  "Wednesday",
  "Thursday",
  "Friday",
  "Saturday",
  "Sunday"
};

// 因为第一维的长度，编译器可以自动计算，所以可以省略。
char weekdays[][10] = {
  "Monday",
  "Tuesday",
  "Wednesday",
  "Thursday",
  "Friday",
  "Saturday",
  "Sunday"
};

// 把数组的第二维，从字符数组改成字符指针
// 其实是一个一维数组，成员就是7个字符指针，每个指针指向一个字符串（字符数组）
char* weekdays[] = {
  "Monday",
  "Tuesday",
  "Wednesday",
  "Thursday",
  "Friday",
  "Saturday",
  "Sunday"
};

// 遍历字符串数组
for (int i = 0; i < 7; i++) {
  printf("%s\n", weekdays[i]);
}
```


c.md

Dart 字符串是 UTF-16 编码的字符序列。
可以使用单引号或者双引号来创建字符串：

```dart
var s1 = 'Single quotes work well for string literals.';
var s2 = "Double quotes work just as well.";
var s3 = 'It\'s easy to escape the string delimiter.';
var s4 = "It's even easier to use the other delimiter.";
```

使用三个单引号或者双引号也可以 创建多行字符串对象：

```dart
var s1 = '''
You can create
multi-line strings like this one.
''';

var s2 = """This is also a
multi-line string.""";
```

```dart
var s = r"In a raw string, even \n isn't special.";
```


dart.md

Go 中的字符串都是采用 UTF-8 字符集编码。
字符串是用一对双引号（""）或反引号（`` ）括起来定义

```go
var frenchHello string  // 声明变量为字符串的一般方法
var emptyString string = ""  // 声明了一个字符串变量，初始化为空字符串
func test() {
  no, yes, maybe := "no", "yes", "maybe"  // 简短声明，同时声明多个变量
  japaneseHello := "Konichiwa"  // 同上
  frenchHello = "Bonjour"  // 常规赋值
}


// Go中字符串是不可变的
var s string = "hello"
s[0] = 'c' // 出错！！！！

s := "hello"
c := []byte(s)  // 将字符串 s 转换为 []byte 类型
c[0] = 'c'
s2 := string(c)  // 再转换回 string 类型
fmt.Printf("%s\n", s2)
```

```go
// `` 括起的字符串为Raw字符串，
// 即字符串在代码中的形式就是打印时的形式，
// 它没有字符转义，换行也将原样输出
m := `hello
  world`
```

```go
package main
import (
    "fmt"
    s "strings"
)
var p = fmt.Println
func main() {
    p("Contains:  ", s.Contains("test", "es"))
    p("Count:     ", s.Count("test", "t"))
    p("HasPrefix: ", s.HasPrefix("test", "te"))
    p("HasSuffix: ", s.HasSuffix("test", "st"))
    p("Index:     ", s.Index("test", "e"))
    p("Join:      ", s.Join([]string{"a", "b"}, "-"))
    p("Repeat:    ", s.Repeat("a", 5))
    p("Replace:   ", s.Replace("foo", "o", "0", -1))
    p("Replace:   ", s.Replace("foo", "o", "0", 1))
    p("Split:     ", s.Split("a-b-c-d-e", "-"))
    p("ToLower:   ", s.ToLower("TEST"))
    p("ToUpper:   ", s.ToUpper("test"))
    p("Len: ", len("hello"))
    p("Char:", "hello"[1])
}

// Contains:   true
// Count:      2
// HasPrefix:  true
// HasSuffix:  true
// Index:      1
// Join:       a-b
// Repeat:     aaaaa
// Replace:    f00
// Replace:    f0o
// Split:      [a b c d e]
// ToLower:    test
// ToUpper:    TEST
// Len:  5
// Char: 101
```


go.md

```js
const x = `------
Line 1
Line 2
Line 3
------`;
```


js.md

```python
x = """------
Line 1
Line 2
Line 3
------"""

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

text = ('Put several strings within parentheses '
        'to have them joined together.')
```

```python
some_string = "abcd"
# 4
print(len(some_string))

'spam eggs'  # single quotes
'doesn\'t'  # use \' to escape the single quote...
"doesn't"  # ...or use double quotes instead
'"Yes," they said.'
"\"Yes,\" they said."
'"Isn\'t," they said.'

print('C:\some\name')  # here \n means newline!
print(r'C:\some\name')  # note the r before the quote

# 字符串可以用 + 进行连接（粘到一起），也可以用 * 进行重复:
# 3 times 'un', followed by 'ium'
3 * 'un' + 'ium'

# 相邻的两个或多个 字符串字面值 （引号引起来的字符）将会自动连接到一起.
'Py' 'thon'
```

```sh
# 字符串是可以被 索引 （下标访问）的，第一个字符索引是 0。
>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

# 索引也可以用负数，这种会从右边开始数:
>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

# 除了索引，字符串还支持 切片。
>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'
```

```python
print(r'C:\some\name')  # note the r before the quote
```


python.md

- 字节 byte（`u8`）
- 字符 character（`char`）
  - 含一个或多个字节
- 字形簇（字母）
- 字符串 string（`String`）
  - `String` 是 `string` 的一种类型
  - 类似还有 `OsString`, `OsStr`, `CString`, and `CStr`
  - `String` 被存储为由字节组成的 `vector`（`Vec<u8>`），但保证了它一定是一个有效的 `UTF-8` 序列。
- 字符串切片 string slice (`&str`)
  - string slice 是 `String` 中一部分值的引用
  - 通常是借用的形式 `&str`
  - `str` 是一个 `DST`；直到运行时我们都不知道字符串有多长。
  - `&str` 是一个总是指向有效 `UTF-8` 序列的切片（`&[u8]`）

## 创建 String

```rust
// 新建一个空的 String
let mut s = String::new();

// 使用 String::from 函数从字符串字面量创建 String
let mut s = String::from("hello");

// 使用 to_string 方法创建 String
// 这里data的类型是 &str 而不是 str
let data = "initial contents";
let s = data.to_string();

// 该方法也可直接用于字符串字面量：
let s = "initial contents".to_string();
```

## 更新 String

```rust
// 使用 push_str 方法向 String 附加字符串 slice
let mut s = String::from("foo");
s.push_str("bar");

// push_str 不会获取所有权
let mut s1 = String::from("foo");
let s2 = "bar";
s1.push_str(s2);
println!("s2 is {}", s2);

// 使用 push 将单个字符加入 String 值中
let mut s = String::from("lo");
s.push('l');

// 使用 + 运算符或 format! 宏拼接 String
let s1 = String::from("Hello, ");
let s2 = String::from("world!");
// 不需要 s2 的所有权，所以加上 &
// 并且 &String 类型被强转成 &str，即 &s2 被转成 &s2[..]
let s3 = s1 + &s2; // 注意 s1 被移动了，不能继续使用
// 因为 add 没有获取参数的所有权，所以 s2 在这个操作后仍然是有效的 String
```

`+` 的定义类似

```rust
let s3 = s1 + &s2;

fn add(self, s: &str) -> String {
```

- `&String` 可以被 强转（coerced）成 `&str`
- 可以发现签名中 `add` 获取了 `self` 的所有权，因为 `self` 没有 使用 `&`。
- 这意味着 `s1` 的所有权将被移动到 `add` 调用中，之后就不再有效。
- 实际上这个语句会获取 `s1` 的所有权，附加上从 `s2` 中拷贝的内容，并返回结果的所有权。

```rust
let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");

let s = s1 + "-" + &s2 + "-" + &s3;
let s = format!("{}-{}-{}", s1, s2, s3); // 使用 format! 宏
```

```rust
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let my_string = String::from("hello world");

    // `first_word` 接受 `String` 的切片，无论是部分还是全部
    let word = first_word(&my_string[0..6]);
    let word = first_word(&my_string[..]);
    // `first_word` 也接受 `String` 的引用，
    // 这等同于 `String` 的全部切片
    let word = first_word(&my_string);

    let my_string_literal = "hello world";

    // `first_word` 接受字符串字面量的切片，无论是部分还是全部
    let word = first_word(&my_string_literal[0..6]);
    let word = first_word(&my_string_literal[..]);

    // 因为字符串字面值**就是**字符串 slice，
    // 这样写也可以，即不使用 slice 语法！
    let word = first_word(my_string_literal);
}
```

```rust
let s = "hello world"; // 这里 s 的类型是 &str，&str 是一个不可变引用
let word = first_word(&s[0..6]);  // 这里 word 的类型也是 &str

let a = [1, 2, 3, 4, 5];
let slice = &a[1..3]; // 这个 slice 的类型是 &[i32]
```

## 索引 String

Rust 的字符串不支持索引。

```rust
let s1 = String::from("hello");
let h = s1[0]; // 错误
```

```rust
let len = String::from("Hola").len();         // 4
let len = String::from("Здравствуйте").len(); // 24

let hello = "Здравствуйте";
let s = &hello[0..4]; // Зд
&hello[0..1] // panic
```

## 遍历 String 的方法

```rust
for c in "नमस्ते".chars() {
    println!("{}", c);
}

// 这些代码会打印出组成 String 的 18 个字节：
for b in "नमस्ते".bytes() {
    println!("{}", b);
}
```

## 转义

```rust
fn main() {
    // 通过转义，可以用十六进制值来表示字节。
    let byte_escape = "I'm writing \x52\x75\x73\x74!";
    println!("What are you doing\x3F (\\x3F means ?) {}", byte_escape);

    // 也可以使用 Unicode 码位表示。
    let unicode_codepoint = "\u{211D}";
    let character_name = "\"DOUBLE-STRUCK CAPITAL R\"";

    println!("Unicode character {} (U+211D) is called {}",
                unicode_codepoint, character_name );


    let long_string = "String literals
                        can span multiple lines.
                        The linebreak and indentation here ->\
                        <- can be escaped too!";
    println!("{}", long_string);
}

fn main() {
    let raw_str = r"Escapes don't work here: \x3F \u{211D}";
    println!("{}", raw_str);

    // 如果你要在原始字符串中写引号，请在两边加一对 #
    let quotes = r#"And then I said: "There is no escape!""#;
    println!("{}", quotes);

    // 如果字符串中需要写 "#，那就在定界符中使用更多的 #。
    // 可使用的 # 的数目没有限制。
    let longer_delimiter = r###"A string with "# in it. And even "##!"###;
    println!("{}", longer_delimiter);
}
```

## 非 UTF-8 字符串

```rust
use std::str;

fn main() {
    // 注意这并不是一个 &str
    let bytestring: &[u8; 20] = b"this is a bytestring";

    // 字节串没有实现 Display，所以它们的打印功能有些受限
    println!("A bytestring: {:?}", bytestring);

    // 字节串可以使用单字节的转义字符...
    let escaped = b"\x52\x75\x73\x74 as bytes";
    // ...但不能使用 Unicode 转义字符
    // let escaped = b"\u{211D} is not allowed";
    println!("Some escaped bytes: {:?}", escaped);


    // 原始字节串和原始字符串的写法一样
    let raw_bytestring = br"\u{211D} is not escaped here";
    println!("{:?}", raw_bytestring);

    // 把字节串转换为 &str 可能失败
    if let Ok(my_str) = str::from_utf8(raw_bytestring) {
        println!("And the same as text: '{}'", my_str);
    }

    let quotes = br#"You can also use "fancier" formatting, \
                    like with normal raw strings"#;

    // 字节串可以不使用 UTF-8 编码
    let shift_jis = b"\x82\xe6\x82\xa8\x82\xb1\x82"; // SHIFT-JIS 编码的 "ようこそ"

    // 但这样的话它们就无法转换成 &str 了
    match str::from_utf8(shift_jis) {
        Ok(my_str) => println!("Conversion successful: '{}'", my_str),
        Err(e) => println!("Conversion failed: {:?}", e),
    };
}
```


字符串

了解更多