blocks|key|134976|text|连接字符串时，需要分配内存来存储结果。最容易入门的是String和&str|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|134977|fn+main()+{
++++let+mut+owned_string:+String+=+"hello+".to_owned();
++++let+borrowed_string:+&str+=+"world";
++++
++++owned_string.push_str(borrowed_string);
++++println!("{}",+owned_string);
}|code-block|syntax|javascript|134978|在这里，我们有一个自己的字符串，我们可以改变它。这是有效的，因为它潜在地允许我们重用内存分配。String和String也有类似的情况，比如&String+can+be+dereferenced+as+&str。|134979|fn+main()+{
++++let+mut+owned_string:+String+=+"hello+".to_owned();
++++let+another_owned_string:+String+=+"world".to_owned();
++++
++++owned_string.push_str(&another_owned_string);
++++println!("{}",+owned_string);
}|134980|在此之后，another_owned_string保持不变(注意没有mut限定符)。还有另一个使用String的变体，但不要求它是可变的。这是一个将String作为左侧，将&str作为右侧的implementation+of+the+Add+trait：|134981|fn+main()+{
++++let+owned_string:+String+=+"hello+".to_owned();
++++let+borrowed_string:+&str+=+"world";
++++
++++let+new_owned_string+=+owned_string+%2B+borrowed_string;
++++println!("{}",+new_owned_string);
}|134982|请注意，在调用%2B之后，将无法再访问owned_string。|134983|如果我们想生成一个新的字符串，而两个字符串都保持不变呢？最简单的方法是使用format!|134984|fn+main()+{
++++let+borrowed_string:+&str+=+"hello+";
++++let+another_borrowed_string:+&str+=+"world";
++++
++++let+together+=+format!("{}{}",+borrowed_string,+another_borrowed_string);

++++//+After+https://rust-lang.github.io/rfcs/2795-format-args-implicit-identifiers.html
++++//+let+together+=+format!("{borrowed_string}{another_borrowed_string}");

++++println!("{}",+together);
}|134985|请注意，两个输入变量都是不可变的，所以我们知道它们没有被修改。如果我们想对String的任何组合做同样的事情，我们可以利用String也可以格式化的事实：|134986|fn+main()+{
++++let+owned_string:+String+=+"hello+".to_owned();
++++let+another_owned_string:+String+=+"world".to_owned();
++++
++++let+together+=+format!("{}{}",+owned_string,+another_owned_string);

++++//+After+https://rust-lang.github.io/rfcs/2795-format-args-implicit-identifiers.html
++++//+let+together+=+format!("{owned_string}{another_owned_string}");
++++println!("{}",+together);
}|134987|不过，您不必使用format!。您可以clone+one+string另一个字符串并将其附加到新字符串：|134988|fn+main()+{
++++let+owned_string:+String+=+"hello+".to_owned();
++++let+borrowed_string:+&str+=+"world";
++++
++++let+together+=+owned_string.clone()+%2B+borrowed_string;
++++println!("{}",+together);
}|134989|注释-我做的所有类型规范都是多余的-编译器可以推断出这里起作用的所有类型。我添加它们只是为了让刚接触Rust的人明白，因为我希望这个问题能在那个群体中流行起来！|BOLD|134990|entityMap|0|LINK|mutability|MUTABLE|url|https://doc.rust-lang.org/std/string/struct.String.html#deref-methods|1|https://doc.rust-lang.org/std/string/struct.String.html#impl-Add%253C%2526%2527_%2520str%253E|2|https://doc.rust-lang.org/std/macro.format.html|3|https://doc.rust-lang.org/std/string/struct.String.html#impl-Clone^0|Q|6|X|4|0|0|1B|6|1I|6|1Y|7|2T|4|26|R|0|0|0|5|K|Y|3|1D|6|22|6|2E|4|39|3|2N|V|1|0|0|7|1|H|C|0|11|7|11|7|2|0|0|11|6|1P|6|0|0|8|7|J|G|3|0|0|0|2|0^^$0|@$1|2|3|4|5|6|7|1N|8|@$9|1O|A|1P|B|C]|$9|1Q|A|1R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1S|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]]|D|@$9|22|A|23|1|24]]|E|$]]|$1|M|3|N|5|H|7|25|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|26|8|@$9|27|A|28|B|C]|$9|29|A|2A|B|C]|$9|2B|A|2C|B|C]|$9|2D|A|2E|B|C]|$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]]|D|@$9|2J|A|2K|1|2L]]|E|$]]|$1|Q|3|R|5|H|7|2M|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|2N|8|@$9|2O|A|2P|B|C]|$9|2Q|A|2R|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|2S|8|@$9|2T|A|2U|B|C]]|D|@$9|2V|A|2W|1|2X]]|E|$]]|$1|W|3|X|5|H|7|2Y|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|2Z|8|@$9|30|A|31|B|C]|$9|32|A|33|B|C]]|D|@]|E|$]]|$1|10|3|11|5|H|7|34|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|35|8|@$9|36|A|37|B|C]]|D|@$9|38|A|39|1|3A]]|E|$]]|$1|14|3|15|5|H|7|3B|8|@]|D|@]|E|$I|J]]|$1|16|3|17|5|6|7|3C|8|@$9|3D|A|3E|B|18]]|D|@]|E|$]]|$1|19|3|-4|5|6|7|3F|8|@]|D|@]|E|$]]]|1A|$1B|$5|1C|1D|1E|E|$1F|1G]]|1H|$5|1C|1D|1E|E|$1F|1I]]|1J|$5|1C|1D|1E|E|$1F|1K]]|1L|$5|1C|1D|1E|E|$1F|1M]]]]

When you concatenate strings, you need to allocate memory to store the result. The easiest to start with is <code>String</code> and <code>&amp;str</code>:
<pre class="lang-rust prettyprint-override"><code>fn main() {
 let mut owned_string: String = &quot;hello &quot;.to_owned();
 let borrowed_string: &amp;str = &quot;world&quot;;
 
 owned_string.push_str(borrowed_string);
 println!(&quot;{}&quot;, owned_string);
}
</code></pre>
Here, we have an owned string that we can mutate. This is efficient as it potentially allows us to reuse the memory allocation. There's a similar case for <code>String</code> and <code>String</code>, as <code>&amp;String</code> <a href="https://doc.rust-lang.org/std/string/struct.String.html#deref-methods" rel="noreferrer">can be dereferenced as <code>&amp;str</code></a>.
<pre class="lang-rust prettyprint-override"><code>fn main() {
 let mut owned_string: String = &quot;hello &quot;.to_owned();
 let another_owned_string: String = &quot;world&quot;.to_owned();
 
 owned_string.push_str(&amp;another_owned_string);
 println!(&quot;{}&quot;, owned_string);
}
</code></pre>
After this, <code>another_owned_string</code> is untouched (note no <code>mut</code> qualifier). There's another variant that consumes the <code>String</code> but doesn't require it to be mutable. This is an <a href="https://doc.rust-lang.org/std/string/struct.String.html#impl-Add%3C%26%27_%20str%3E" rel="noreferrer">implementation of the <code>Add</code> trait</a> that takes a <code>String</code> as the left-hand side and a <code>&amp;str</code> as the right-hand side:
<pre class="lang-rust prettyprint-override"><code>fn main() {
 let owned_string: String = &quot;hello &quot;.to_owned();
 let borrowed_string: &amp;str = &quot;world&quot;;
 
 let new_owned_string = owned_string + borrowed_string;
 println!(&quot;{}&quot;, new_owned_string);
}
</code></pre>
Note that <code>owned_string</code> is no longer accessible after the call to <code>+</code>.
What if we wanted to produce a new string, leaving both untouched? The simplest way is to use <a href="https://doc.rust-lang.org/std/macro.format.html" rel="noreferrer"><code>format!</code></a>:
<pre class="lang-rust prettyprint-override"><code>fn main() {
 let borrowed_string: &amp;str = &quot;hello &quot;;
 let another_borrowed_string: &amp;str = &quot;world&quot;;
 
 let together = format!(&quot;{}{}&quot;, borrowed_string, another_borrowed_string);

 // After https://rust-lang.github.io/rfcs/2795-format-args-implicit-identifiers.html
 // let together = format!(&quot;{borrowed_string}{another_borrowed_string}&quot;);

 println!(&quot;{}&quot;, together);
}
</code></pre>
Note that both input variables are immutable, so we know that they aren't touched. If we wanted to do the same thing for any combination of <code>String</code>, we can use the fact that <code>String</code> also can be formatted:
<pre class="lang-rust prettyprint-override"><code>fn main() {
 let owned_string: String = &quot;hello &quot;.to_owned();
 let another_owned_string: String = &quot;world&quot;.to_owned();
 
 let together = format!(&quot;{}{}&quot;, owned_string, another_owned_string);

 // After https://rust-lang.github.io/rfcs/2795-format-args-implicit-identifiers.html
 // let together = format!(&quot;{owned_string}{another_owned_string}&quot;);
 println!(&quot;{}&quot;, together);
}
</code></pre>
You don't have to use <code>format!</code> though. You can <a href="https://doc.rust-lang.org/std/string/struct.String.html#impl-Clone" rel="noreferrer">clone one string</a> and append the other string to the new string:
<pre class="lang-rust prettyprint-override"><code>fn main() {
 let owned_string: String = &quot;hello &quot;.to_owned();
 let borrowed_string: &amp;str = &quot;world&quot;;
 
 let together = owned_string.clone() + borrowed_string;
 println!(&quot;{}&quot;, together);
}
</code></pre>
Note - all of the type specification I did is redundant - the compiler can infer all the types in play here. I added them simply to be clear to people new to Rust, as I expect this question to be popular with that group!

blocks|key|136803|text|要将多个字符串连接成由另一个字符分隔的单个字符串，有两种方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|136804|我见过的最好的方法是在数组上使用join方法：|offset|length|style|CODE|136805|fn+main()+{
++++let+a+=+"Hello";
++++let+b+=+"world";
++++let+result+=+[a,+b].join("\n");

++++print!("{}",+result);
}|code-block|syntax|javascript|136806|根据您的用例，您可能还喜欢更多的控制：|136807|fn+main()+{
++++let+a+=+"Hello";
++++let+b+=+"world";
++++let+result+=+format!("{}\n{}",+a,+b);

++++print!("{}",+result);
}|136808|我已经看到了一些更多的手动方法，其中一些避免了这里或那里的一两个分配。出于可读性的目的，我发现上面两个就足够了。|136809|entityMap^0|0|G|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

To concatenate multiple strings into a single string, separated by another character, there are a couple of ways.

The nicest I have seen is using the <code>join</code> method on an array:

<pre><code>fn main() {
 let a = "Hello";
 let b = "world";
 let result = [a, b].join("\n");

 print!("{}", result);
}
</code></pre>

Depending on your use case you might also prefer more control:

<pre><code>fn main() {
 let a = "Hello";
 let b = "world";
 let result = format!("{}\n{}", a, b);

 print!("{}", result);
}
</code></pre>

There are some more manual ways I have seen, some avoiding one or two allocations here and there. For readability purposes I find the above two to be sufficient.

blocks|key|136817|text|我认为这里也应该提到concat方法和%2B：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|136818|assert_eq!(
++("My".to_owned()+%2B+"+"+%2B+"string"),
++["My",+"+",+"string"].concat()
);|code-block|syntax|javascript|136819|还有一个concat!宏，但仅用于文字：|136820|let+s+=+concat!("test",+10,+'b',+true);
assert_eq!(s,+"test10btrue");|136821|entityMap|0|LINK|mutability|MUTABLE|url|https://doc.rust-lang.org/1.0.0/std/slice/trait.SliceConcatExt.html#tymethod.concat|1|https://doc.rust-lang.org/1.0.0/std/macro.concat!.html^0|A|6|J|1|A|6|0|0|0|4|7|4|7|1|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|M|3|N|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]|W|$5|R|S|T|E|$U|X]]]]

I think that <a href="https://doc.rust-lang.org/1.0.0/std/slice/trait.SliceConcatExt.html#tymethod.concat" rel="noreferrer"><code>concat</code></a> method and <code>+</code> should be mentioned here as well:

<pre class="lang-rust prettyprint-override"><code>assert_eq!(
 ("My".to_owned() + " " + "string"),
 ["My", " ", "string"].concat()
);
</code></pre>

and there is also <a href="https://doc.rust-lang.org/1.0.0/std/macro.concat!.html" rel="noreferrer"><code>concat!</code></a> macro but only for literals:

<pre class="lang-rust prettyprint-override"><code>let s = concat!("test", 10, 'b', true);
assert_eq!(s, "test10btrue");
</code></pre>

blocks|key|2914678|text|在Rust中连接字符串的简单方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2914679|Rust中提供了多种连接字符串的方法|2914680|第一种方法(使用concat!()+)：|offset|length|style|CODE|2914681|fn+main()+{
++++println!("{}",+concat!("a",+"b"))
}|code-block|syntax|javascript|2914682|上述代码的输出为：|2914683|2914684|+ab|blockquote|2914685|2914686|2914687|2914688|第二种方法(使用push_str()和%2B运算符)：|2914689|fn+main()+{
++++let+mut+_a+=+"a".to_string();
++++let+_b+=+"b".to_string();
++++let+_c+=+"c".to_string();

++++_a.push_str(&_b);

++++println!("{}",+_a);

++++println!("{}",+_a+%2B+&_c);
}|2914690|2914691|2914692|+ab|2914693|2914694|abc|2914695|2914696|2914697|第三种方法(Using+format!())：|2914698|fn+main()+{
++++let+mut+_a+=+"a".to_string();
++++let+_b+=+"b".to_string();
++++let+_c+=+format!("{}{}",+_a,+_b);

++++println!("{}",+_c);
}|2914699|2914700|2914701|+ab|2914702|2914703|2914704|请查看它并尝试使用Rust+playground。|2914705|entityMap|0|LINK|mutability|MUTABLE|url|https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=f50feb4d857982551eb462abe3a01acc^0|0|0|8|9|0|0|0|0|0|0|0|0|8|A|J|1|0|0|0|0|0|0|0|0|0|6|F|0|0|0|0|0|0|0|9|F|0|0^^$0|@$1|2|3|4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1W|8|@$F|1X|G|1Y|H|I]]|9|@]|A|$]]|$1|J|3|K|5|L|7|1Z|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|20|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|21|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|22|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|24|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|25|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|26|8|@$F|27|G|28|H|I]|$F|29|G|2A|H|I]]|9|@]|A|$]]|$1|Z|3|10|5|L|7|2B|8|@]|9|@]|A|$M|N]]|$1|11|3|P|5|6|7|2C|8|@]|9|@]|A|$]]|$1|12|3|-4|5|6|7|2D|8|@]|9|@]|A|$]]|$1|13|3|14|5|T|7|2E|8|@]|9|@]|A|$]]|$1|15|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2G|8|@]|9|@]|A|$]]|$1|18|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]|$1|19|3|-4|5|6|7|2I|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|2J|8|@$F|2K|G|2L|H|I]]|9|@]|A|$]]|$1|1C|3|1D|5|L|7|2M|8|@]|9|@]|A|$M|N]]|$1|1E|3|P|5|6|7|2N|8|@]|9|@]|A|$]]|$1|1F|3|-4|5|6|7|2O|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|T|7|2P|8|@]|9|@]|A|$]]|$1|1I|3|-4|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|1J|3|-4|5|6|7|2R|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|2S|8|@]|9|@$F|2T|G|2U|1|2V]]|A|$]]|$1|1M|3|-4|5|6|7|2W|8|@]|9|@]|A|$]]]|1N|$1O|$5|1P|1Q|1R|A|$1S|1T]]]]

<h2>Simple ways to concatenate strings in Rust</h2>
There are various methods available in Rust to concatenate strings
<h2>First method (Using <code>concat!()</code> ):</h2>
<pre><code>fn main() {
 println!(&quot;{}&quot;, concat!(&quot;a&quot;, &quot;b&quot;))
}
</code></pre>
The output of the above code is :
<blockquote>
ab
</blockquote>
<hr />
<h2>Second method (using <code>push_str()</code> and <code>+</code> operator):</h2>
<pre><code>fn main() {
 let mut _a = &quot;a&quot;.to_string();
 let _b = &quot;b&quot;.to_string();
 let _c = &quot;c&quot;.to_string();

 _a.push_str(&amp;_b);

 println!(&quot;{}&quot;, _a);

 println!(&quot;{}&quot;, _a + &amp;_c);
}
</code></pre>
The output of the above code is:
<blockquote>
ab
abc
</blockquote>
<hr />
<h2>Third method (<code>Using format!()</code>):</h2>
<pre><code>fn main() {
 let mut _a = &quot;a&quot;.to_string();
 let _b = &quot;b&quot;.to_string();
 let _c = format!(&quot;{}{}&quot;, _a, _b);

 println!(&quot;{}&quot;, _c);
}
</code></pre>
The output of the above code is :
<blockquote>
ab
</blockquote>
Check it out and experiment with <a href="https://play.rust-lang.org/?version=stable&amp;mode=debug&amp;edition=2018&amp;gist=f50feb4d857982551eb462abe3a01acc" rel="noreferrer">Rust playground</a>.

blocks|key|133990|text|通过字符串插值进行连接|type|unstyled|depth|inlineStyleRanges|entityRanges|data|133991|RFC2795发布2019-10-27:建议支持隐式参数，以实现许多人所知的“字符串插值”--一种将参数嵌入到字符串中以连接它们的方式。|133992|RFC：https://rust-lang.github.io/rfcs/2795-format-args-implicit-identifiers.html|offset|length|133993|最新问题状态可在此处找到：https://github.com/rust-lang/rust/issues/67984|133994|在写这篇文章的时候(2020-9-24)，我相信这个特性应该可以在Rust+Nightly+build中使用。|133995|这将允许您通过以下速记进行连接：|133996|format_args!("hello+{person}")|code-block|syntax|javascript|133997|等同于：|133998|format_args!("hello+{person}",+person=person)|133999|还有"ifmt“crate，它提供了自己的字符串插值：|134000|https://crates.io/crates/ifmt|134001|entityMap|0|LINK|mutability|MUTABLE|url|https://rust-lang.github.io/rfcs/2795-format-args-implicit-identifiers.html|1|https://github.com/rust-lang/rust/issues/67984|2^0|0|0|4|23|0|0|D|1A|1|0|0|0|0|0|0|0|0|T|2|0^^$0|@$1|2|3|4|5|6|7|1B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1C|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1D|8|@]|9|@$F|1E|G|1F|1|1G]]|A|$]]|$1|H|3|I|5|6|7|1H|8|@]|9|@$F|1I|G|1J|1|1K]]|A|$]]|$1|J|3|K|5|6|7|1L|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1M|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1N|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1O|8|@]|9|@]|A|$]]|$1|U|3|V|5|P|7|1P|8|@]|9|@]|A|$Q|R]]|$1|W|3|X|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1R|8|@]|9|@$F|1S|G|1T|1|1U]]|A|$]]|$1|10|3|-4|5|6|7|1V|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]|18|$5|13|14|15|A|$16|19]]|1A|$5|13|14|15|A|$16|Z]]]]

<h2>Concatenation by String Interpolation</h2>
RFC 2795 issued 2019-10-27:
Suggests support for implicit arguments to do what many people would know as &quot;string interpolation&quot; -- a way of embedding arguments within a string to concatenate them.
RFC: <a href="https://rust-lang.github.io/rfcs/2795-format-args-implicit-identifiers.html" rel="nofollow noreferrer">https://rust-lang.github.io/rfcs/2795-format-args-implicit-identifiers.html</a>
Latest issue status can be found here:
<a href="https://github.com/rust-lang/rust/issues/67984" rel="nofollow noreferrer">https://github.com/rust-lang/rust/issues/67984</a>
At the time of this writing (2020-9-24), I believe this feature should be available in the Rust Nightly build.
This will allow you to concatenate via the following shorthand:
<pre><code>format_args!(&quot;hello {person}&quot;)
</code></pre>
It is equivalent to this:
<pre><code>format_args!(&quot;hello {person}&quot;, person=person)
</code></pre>
There is also the &quot;ifmt&quot; crate, which provides its own kind of string interpolation:
<a href="https://crates.io/crates/ifmt" rel="nofollow noreferrer">https://crates.io/crates/ifmt</a>

blocks|key|136959|text|默认情况下，Rust是关于MemoryManage、Owenership和Move的，我们通常不会看到like+copy或deep+copy，因此如果你试图连接字符串，那么左侧应该键入String，它是可增长的，并且应该是可变类型，右侧可以是正常的字符串文字，也就是a类型的string+slices|type|unstyled|depth|inlineStyleRanges|entityRanges|data|136960|++++fn+main+(){
++++++++++++let+mut+x+=+String::from("Hello");+//+type+String
++++++++++++let+y+=+"World"+//+type+&str
++++++++++++println!("data+printing+------->+{}",x%2By);



}|code-block|syntax|javascript|136961|文档中的官方声明，这是您尝试使用arthmatic+%2B运算符时所指向的|offset|length|style|BOLD|136962|📷|atomic|136963|​|136964|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/e9d772d4cc853517005d94f9d44c4e30.png|imageAlt^0|0|0|4|Q|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|O|7|15|8|@]|9|@$I|16|J|17|1|18]]|A|$]]|$1|P|3|Q|5|6|7|19|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y|Z|-4]]]]

By Default in Rust is all about MemoryManage and Owenership and Move, we dont see usually like copy or deep copy hence
if you are trying to concatinate strings then left hand side should type String which is growable and should be mutable type, the right hand side can be normal string literal a.k.a type String slices
<pre><code> fn main (){
 let mut x = String::from(&quot;Hello&quot;); // type String
 let y = &quot;World&quot; // type &amp;str
 println!(&quot;data printing -------&gt; {}&quot;,x+y);



}
</code></pre>
official statement from doc, this is pointing to when you are trying using arthmatic + operator
<a href="https://i.stack.imgur.com/h6WQI.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/h6WQI.png" alt="enter image description here" /></a>

blocks|key|2915153|text|从Rust1.58开始，您还可以像这样连接两个或更多变量：format!("{a}{b}{c}")。这基本上与format!("{}{}{}",+a,+b,+c)相同，但更短一些，(可以说)更容易阅读。这些变量可以是String、&str+(也可以是其他非字符串类型)。结果是一个String。有关详细信息，请参阅this。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2915154|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/70504075^0|T|K|1J|Q|30|6|37|4|3W|6|4D|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|F|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

As of Rust 1.58, you can also concatenate two or more variables like this: <code>format!(&quot;{a}{b}{c}&quot;)</code>. That's basically the same as <code>format!(&quot;{}{}{}&quot;, a, b, c)</code>, but a bit shorter and (arguably) easier to read. Those variables can be <code>String</code>, <code>&amp;str</code> (and also other non-string types for that matter). The result is a <code>String</code>.
See <a href="https://stackoverflow.com/a/70504075">this</a> for more.

blocks|key|134106|text|fn+main()+{
++++let+a+=+String::from("Name");
++++let+b+=+"Pkgamer";
++++println!("{}",a%2Bb)
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|134107|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>fn main() {
 let a = String::from(&quot;Name&quot;);
 let b = &quot;Pkgamer&quot;;
 println!(&quot;{}&quot;,a+b)
}
</code></pre>

How do I concatenate the following combinations of types:

<ul>
<li><code>str</code> and <code>str</code></li>
<li><code>String</code> and <code>str</code></li>
<li><code>String</code> and <code>String</code></li>
</ul>

How do I concatenate strings?

编译器

如何连接以下类型的组合：str和strString以及strString和String

问如何连接字符串？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何连接字符串？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何连接字符串？
EN