js 如何优雅的拼接 字符串

JavaScript022

js 如何优雅的拼接 字符串,第1张

JS中有三种字符串连接方式:

第一种方法 , 用连接符“+”把要连接的字符串连起来：

str="a"str+="b"

第二种方法， 以数组作为中介用 join 连接字符串：

var arr=new Array()arr.push(a)arr.push(b)var str=arr.join("")

第三种方法， 利用对象属性来连接字符串：

function stringConnect(){this._str_=new Array()}stringConnect.prototype.append=function(a){this._str_.push(a)}stringConnect.prototype.toString=function(){return this._str_.join()}var mystr=new stringConnect

mystr.append("a") var str=mystr.toString()

JS中三种字符串连接方式的性能比较：

第一种，方法毫无疑问是最便捷快速的，如果只连接100个以下的字符串建议用这种方法最方便；

第二种，这种方法要比第一种消耗更少的资源，速度也更快；

第三种，方法加入了随机参数，应该是避免了缓存的影响的。

交叉合并：如字符串一为：abcd  字符串二为：1234。则结果为：a1b2c3d4。

import java. util. ArrayListimport java. util. Listpublic class A {

public static void main(string[] args){

string a[]={"a","b","c"}

string b[]={"1","2","3"}

CombineTwoArray(a,b)

system. out. println(CombineTwoArray(a,b))

}

public static List<string>combineTwoArray(string[] first, String[] second)t List<string>outlist=new ArrayList<string>()

int index=0

while(index<first. length &&index<second. length){

outlist. add(first[ index])outlist. add(second[ index])

++indexif(index>=first. length){

for (int i=indexi<second. lengthi++){

outlist. add(second[i])

}

} else{

for (int i=indexi<first. lengthi++){

outlist. add(first[i])

}

return outlist

}

}

js的写法：

<！DOCTYPE html pUBLIC"-//w3c//DTD XHTMT 1.0

Transitional//EN""http://www.w3.org/TR/xhtm11/DrD/xhtml1-transitional.dtd">

<htmlxmlns="http://www.w3.org/1999/xhtm1">

<head>

<title>第十五题：交叉合并字符串</title>

<style>

#form{

margin：0auto；width：500px；top：100px；height：300px；

</style>

<script type="text/javascript">

var reg="*[A-za-20-9]+$"；function check（）{

var strl =document.all.strl.value；var str2 =document.all.str2.value；if（str1==""）{

alert（“字符串一不允许为空！"）；document.all.strl.focus（）；return；

}else if（！/^[A-2a-20-9]+$/.test（str1））{

alert（"字符串一只能是数字和字母的组合"）；document.all.str1.focus（）；return；

}else if（str2==""）{

alert（”字符串二不允许为空！"）；document.all.str2.focus（）；

return；

}else if（！/^[A-Za-20-9]+5/.test（str2））{

alert（“字符串二只能是数字和字母的组合"）；document.a1l.str2.focus（）；return；var string=""；var font1="<font style='color:red；'>"；var font2="<font style='color:blue；'>"；var fontend="</font>"；if（str1.1ength>=str2.1ength）{

for（vari=0；i<str1.1ength；i++）{

if（i<str2.length）{

string +=font1+strl[i]+fontend+ font2+ str2[i]+fontend；

}else{

string+=font1+strl[il；

}else{

for（var i=0；i<str2.1ength；i++）{

if（i<strl.length）{

document.all.result.innerHTML=string；

</script>

</head>

<body>

<div id="form">

<center><h2>第十五题：交叉合并字符串</h2></center>

字符串1：<input type="text"id="str1"/><br/>字符串2：<input type="text"id="str2"/><br/>

<input type="button"value="交叉合并字符串”onclick="check（）；"/>

<br/>

<div id="result"></div>

</div>

</body></html>

string+=font1+strl[i]+fontend+font2+str2[i]+fontend；

}else{

string+=font2+str2[i]+fontend；

扩展资料：

/**

* 合并两个函数

* @param functionA 先执行

* @param functionB 执行完 functionA 后返回

* @returns {*}

*/

function mergeFunction (functionA, functionB) {

if (!functionA || !functionB) return

var merge = functionB

functionB = (function () {

merge.call(this)

functionA.call(this)

})()

return functionB = merge

}

大家都知道StringBuilder在拼接大量字符串的时候相对String来说具有很高的效率，这是由于StringBuilder在内部处理上使用了字符串的链式存储表示法（串的块链存储法）。串的块链存储结构的C代码是这样的：

#define CHUNKSIZE 80

typedef struct Chunk

{

char ch[CHUNKSIZE]

struct Chunk* next

}Chunk

由此，可以看到它同时具有线性表和链表的特性。我们可以类比的想象一下，把上面的代码改写成下面的C#代码：

class StringBuilder

{

private char[] ch

private StringBuilder next

}

其实上面的这段C#代码就是StringBuilder的一部分定义了，但StringBuilder中为了快速的获取到字符串的长度以及更方便的输出字符串，它保存了一个Offset字段，这个字段记录了所有后继结点（next）里ch的长度之和。明显头结点ch中字符的长度（非数组长度）与这个offset的和就是整个字符串的长度Length，这样显得更高效避免了遍历字符串求长度的开销。

当我们初始化StringBuilder的时候，在构造函数中允许我们传入capacity、maxcapacity以及string参数，capacity就是我们这里ch数组的长度，而maxcapacity是最大的可容下的字符串长度，也就是说Length的长度必须小于maxcapacity。随便说一句，capacity和maxcapacity的默认值分别是16和2147483647。

说了那么多原理性的东西，下面来看看一段使用StringBuilder添加字符串的代码，后面，我会使用图文来解析StringBuilder内部的工作方式。

//chuncksize=16,目前还有3个空闲

var strb = new StringBuilder("abcdefghijklm")

var input=Console.ReadLine()

strb.Append(input)

下面我们分输入的情况来讨论：

1.如果input的长度小于等于3：

当strb的内部发现当前Append的字符串长度小于strb中chunck中剩余的长度,就会直接将输入字符串添加到末尾。

2.如果input的长度大于3：

如果input的长度大于strb中ch剩余长度的时候，那么就要对strb进行“断裂”了，也就是说将input前一部分的值放到strb中去，同时将input剩下的值放到新创建的StringBuilder（也就是next）当中。

请注意strb中和strbNew中的蓝色部分，这不是巧合相等，它们确实是相等的长度，在“断裂”后，系统会重新为strb分配存储空间，这个存储空间中空闲的部分恰恰就是没有断裂前chunck中的长度。我还必须说明的一点是，在“断裂”过后，还会重新设置strb的offset，这个offset实际上就是strbNew的长度而且这个是一个循环递归的过程，在下一次strb满的时候又会执行整个这个过程。

StringBuilder的整个过程就是一个串的块链存储法的实现，它也用到了数组拷贝，但是它是通过unsafe代码来实现的，所以性能相对于托管代码要高一点。