javascript对象——字符串对象

1.基本包装类型

        基本包装类型：就是把简单数据类型  包装成为了 复杂数据类型

            var str = 'anday';
			console.log(str.length);
			// 这两行代码在js里面进行了包装

			// 1）把简单的数据类型包装成复杂数据类型.
			var temp = new String ('anday');
			// 2)把临时变量给str.
			str=temp;
			// 3)销毁这个临时变量.
			temp=null;

 2.字符串的不可变性

            var str='andy';
			console.log(str);
			str='red';
			console.log(str);

         总结：根据代码显示可以知道，虽然str刚刚开始赋值为andy 后面又重新给他赋值为red，后面打印输出str 的时候，虽然输出的为red，但是andy是在内存中存储的，只是调用输出str的时候，str指向的是red，而不是之前的andy。所以由上总结得出，根据字符串的不可变性，所以我们不能大量的拼接字符串，否则会导致系统进行卡顿

验证代码：不介意执行

            // var  str = '';
			// for (var i=1; i<=1000000 ; i++){
			// 	str += i;
			// }
			// console.log(str);

			// 假设这里遍历相加的字符串过大，就会导致系统处理时过载

3.根据字符返回位置  str.indexOf  indexOf可以作为对字符串里面的元素进行查找，查找不到的情况下，返回的就是-1，查找到了就会放回数值所在的索引号位置，可以通过这个方法判断数组里面是否有该元素  ('要查找的字符'，[起始位置])

            var str = '改革春分吹满地，春天来了';
			console.log(str.indexOf('春'));
			// 这里的春在返回字符串所在位置的时候，和数组一样也是只返回第一个匹配对象的位置

			console.log(str.indexOf('春', 3));
			// 这里的3，是查找的时候从索引号为3的地方进行查找

 

案例：返回字符位置        查找字符串'abcoefoxyozzopp'中所有o出现的位置和次数

核心算法：先查找第一个o出现的位置
                  然后  只要indexOf 返回的结果不是-1 就继续往后查找
                  因为indexOf 只能查找第一个，所以后面的查找，一定是当前索引加1，从而继续查找

 

            var str = 'abcoefoxyozzopp';
			var index = str.indexOf('o');
			// 查找第一个o出现的位置
			var num = 0;
			while (index !== -1) {
				// console.log(index);
				num++;
				index = str.indexOf('o', index + 1);
				// 这里查找一个新的o出现的位置，然后将他赋值给index，然后重新进入while判断，直到最后找不到o的位置信息，就返回一个-1，因为符合while判断条件，所以最后终止循环
			}
			console.log('o出现的次数是：' + num)

案例：['red','blue','red','blue','red','pink','green','red']求'red'出现的位置和次数。

var arr = ['red', 'blue', 'red', 'blue', 'red', 'pink', 'green', 'red'];
			var index1 = arr.indexOf('red');
			// 先查找第一个red出现的位置，将位置信息赋值给index1
			var num = 0;
			while (index1 !== -1) {
				// 因为位置信息不等于-1，所以进入while循环
				// console.log(index1);
				num++;
				index1 = arr.indexOf('red', index1 + 1);
				// 这里查找一个新的red出现的位置，然后将他赋值给index，然后重新进入while判断，直到最后找不到red的位置信息，就返回一个-1，因为符合while判断条件，所以最后终止循环
			}
			console.log('red出现的次数是：' + num);

 4.根据位置返回字符  (重点)

 1）charAt(index) 根据位置返回字符（这里的index 就是要求返回的索引号位置）

            var str = 'andy';
			console.log(str.charAt(2));
			// 遍历所有的字符
			for (var i = 0; i < str.length; i++) {
				console.log(str.charAt(i));
			}

2)charCodeAt(index) 返回相应索引号的字符对应的ASCII码  目的：判断用户按下了哪一个键

            console.log(str.charCodeAt(0));
			// 这里返回的是索引号为0对应的字母a所对应的ACSII码

 

3）有一个对象  判断里面是否有该属性   对象['属性名'](可以判断对象里面是否有该属性)

            var o = {
				age: 18,
			}
			if (o['age']) {
				console.log('里面有该属性')
			} else {
				console.log('里面没有该属性')
			}

 案例：查找字符串'abcoefoxyozzopp'中出现次数最多的字符，并统计次数

核心算法：利用charAt() 遍历这个字符串。
                  把每个字符都存储给对象，如果对象没有该属性，就为1，如果存在了就+1
                  遍历对象，得到最大值和该字符

            var str = 'abcoefoxyozzopp';
			var d = {};
			for (var i = 0; i < str.length; i++) {
				var chars = str.charAt(i);
				// chars是字符串的每一个字符
				if (d[chars]) {
					// d[chars]得到的是属性值
					d[chars]++;
					//这里是循环遍历遇到第二个相同的字母时，就在1 的基础上进行++操作。
				} else {
					d[chars] = 1;
					//这里是循环遇到第一次出现的字母，给每个字母赋值为1.
				}
			}
			console.log(d);
			// 遍历对象
			var max = 0;
			var ch = '';
			for (k in d) {
				// k只在for里面有用，出for循环就丧失了作用
				// k得到的是属性名
				// d[k]得到的是属性值
				if (d[k] > max) {
					max = d[k];
					ch = k;
				}
			}
			console.log(max);
			console.log('最多的字符是：' + ch)

 

5.字符串操作方法(重点)

1）concat ('字符串1','字符串2',……); 拼接字符串

            var str = 'andy';
			console.log(str.concat('read'));
			// 但是在日常当中我们字符串的拼接大多都是使用'+'进行字符串的拼接

 2）substr('截取的起始位置','截取几个字符');

            var str1 = '改革春风吹满地';
			console.log(str1.substr(2, 2));
			// 第一个2是索引号的2  ，第二个2是截取几个字符

 3）替换字符 replace('被替换的字符','替换为的字符')

            var str2 = 'andyand';
			console.log(str2.replace('a', 'b'));
			// 他只会替换第一个字符

			// 有一个字符串'abcoefoxyozzopp'，要求把所有的o替换为*
			var str4 = 'abcoefoxyozzopp';
			while (str4.indexOf('o') !== -1) {
				str4 = str4.replace('o', '*');
			}
			console.log(str4);

 

4)字符串转换为数组 split('分隔符')     里面的分割符，取决于数组当中用什么将他们划分开，只有划分开才可以转化为数组

            var str2 = 'red,pink,blue';
			console.log(str2.split(','));
			var str3 = 'red&pink&blue';
			console.log(str3.split('&'));

 

5）转换为大写  toUpperCase()  将调用该方法的字符串值转为大写形式，并返回。

	// 返回转为大写形式的字符串。此方法不会影响原字符串本身的值，
			var str6 = 'red,pink,blue';
			console.log(str6.toUpperCase());

  6)转换为小写  toLowerCase()   会将调用该方法的字符串值转为小写形式，并返回。

// 会将调用该方法的字符串值转为小写形式，并返回。
			var str7 = 'RED,pink,blue';
			console.log(str7.toLowerCase());

 

字符串案例：给定一个字符，如：'abaasdffggghhjjkkgfddsssss3443334';

            // 1：求字符串的长度。
			var str10 = 'abaasdffggghhjjkkgfddsssss3443334';
			console.log(str10.length);

			// 2.取出指定位置的字符。
			//使用charAt(index)来取出指定位置的字符
			console.log(str10.charAt(3))
			//H5新增的取出指定位置的字符
			console.log(str10[2])

			// 3.查找指定字符是否在以上字符中存在。
			var str11 = 'abaasdffggghhjjkkgfddsssss3443334';
			console.log(str11.indexOf('j'));
			console.log(str11.indexOf('i'));
			console.log(str11.indexOf('c'));
			console.log(str11.indexOf('b'));
			// 查找的字符如果在字符串中存在，就会返回该字符在字符串中的位置，如果查找的字符在字符串中不存在，返回的就是-1(代表的就是该字符不在字符串)

			// 4.替换指定的字符，如：g 替换为22 ，s 替换为b。
			var str12 = 'abaasdffggghhjjkkgfddsssss3443334';
			while (str12.indexOf('g') !== -1) {
				str12 = str12.replace('g', '22');
			}
			console.log(str12);


			var str13 = 'abaasdffggghhjjkkgfddsssss3443334';
			while (str13.indexOf('s') !== -1) {
				str13 = str13.replace('s', 'b')
			}
			console.log(str13);

			// 5.截取指定开始位置到结束位置的字符串。
			var str14 = 'abaasdffggghhjjkkgfddsssss3443334';
			console.log(str14.substring(2, 10));
			//2是截取字符开始的位置，10是截取的字符熟练

			var str15 = 'abaasdffggghhjjkkgfddsssss3443334';
			console.log(str15.substring(2, 10));
			// substring(start,end)  这里面的数字2是开始的索引号位置，10是截取的结束索引号位置，但是截取的方式为[start,end)

			var str16 = 'abaasdffggghhjjkkgfddsssss3443334';
			console.log(str16.substring(16, -6));
			var str17 = 'abaasdffggghhjjkkgfddsssss3443334';
			console.log(str16.substring(-6, 2));
			// substring 里面任何一个参数为 0 或为 NaN，则被当作 0。截取字符的时候则直接从字符最开始截取到任何一个不为0的索引位置。

			var str18 = 'abaasdffggghhjjkkgfddsssss3443334';
			console.log(str18.slice(2, 10));
			// slice 的截取数值的方式和substring相同，但是该方法不接受负值。

			var str19 = 'abaasdffggghhjjkkgfddsssss3443334';
			console.log(str19.slice(-4));
			//表示提取原数组中的倒数第四个元素到最后一个元素（包含最后一个元素）。
			var str20 = 'abaasdffggghhjjkkgfddsssss3443334';
			console.log(str20.slice(5, -2));
			//表示从第索引号为5的元素开始抽取，抽取到数组的倒数第二个元素（但是不包含倒数第二个元素）
			// slice的参数不支持slice(begin，end)  begin为负数，end为正数，因为slice里面为负值时，是从倒数第一个元素开始抽取，如果抽取开始的位置为负，停止的位置为正，则不会显示结果

			// 6.找出以上次数出现最多的字符，并统计出现的次数。
			var str21 = 'abaasdffggghhjjkkgfddsssss3443334';
			var w = {};
			for (var i = 0; i < str21.length; i++) {
				var cha = str21.charAt(i);
				if (w[cha]) {
					w[cha]++
				} else {
					w[cha] = 1;
				}
			}
			console.log(w);
			//前面获取每个字母出现的字数
			// 遍历对象
			var max = 0;
			var chas = ''
			for (k in w) {
				//w[k]得到的是里面的属性值
				if (w[k] > max) {
					max = w[k]
					chas = k
				}
			}
			console.log(max);
			console.log('次数出现最多的数:' + chas)

 追加案例：编写函数删除字符串中的数字（对replace进行深度的理解）

            // 第三种：替换原字符符
			function numDelete(arr) {
				for (var i = 0; i < arr.length;i++) {
					if (!isNaN(arr[i])) {
						// console.log(arr[i])
						arr = arr.replace(arr[i], '')
								// i--;
						//加上该代码之后，就可以删除里面的所有数字
					}
				}
				return arr;
			}
			// document.write(numDelete("123456shd12345wh"));   //246shd24wh
			//这一行数字的显示是偶数位得以保留，奇数位数字删除
			document.write(numDelete("343334shd34344wh"));   //4shd4344wh

在没有加i--时，为什么第二个打印输出的结果是4shd4344wh

个人理解：因为这个前面获取到的arr[i]是一个具体的数字，而replace他每次替换的是找到与值对应的第一个数字，所以虽然arr[6]对应的数字是3，但是因为前面偶数保留下来的3会优先被搜索到，所以删除的就是前面的3，所以后面的3 得以保留，同理前面偶数保留下来的数字，正好被后面相等的数字安排为优先搜索到被删除，主要的就是后面要删除的数字都在前面被搜索到，所以最后就得出了该结果。