JavaScript入门 选择排序/快速排序/数组去重/字符串创建/字符串常用方法 Day07

数组的排序

---

选择排序

• n个数进行n-1次选择
• 每次选择，未排序数中找最小数下标，与前面的数交换位置

              var arr = [89, 98, 78, 68, 76]
  			      //    0    1   2   3  4
  			var n = arr.length
  
  			//外层循环
  			for (var i = 0; i < n - 1; i++) {
  
  				//找最小数下标
  				var minIndex = i //假设最小数下标是第一个数
  				for (var j = i+1; j < n; j++) {
  					if (arr[j] < arr[minIndex]) {
  						minIndex = j
  					}
  				}
  				//交换位置
  				var temp = arr[i]
  				arr[i] = arr[minIndex]
  				arr[minIndex] = temp
  
  				console.log('第'+(i+1)+'次选择 ',arr)
  			}
  
  			console.log(arr)

数组去重 [面试]

思路1：定义一个空数组去存储重复元素;遍历数组,判断新数组中是否有原数组的元素,没有就存储

var arr = [9,2,5,2,8,2,5]
var newArr = []   //存储去重元素
for(var i = 0 ; i < arr.length ; i++){
   if (!newArr.includes(arr[i])){   //判断新数组中是否有原数组当前元素，没有就存储进新数组
     newArr.push(arr[i])
    }
} 
console.log(newArr)

   
                function test2() {
				var arr = [9, 2, 5, 2, 8, 2, 5]
				var newArr = [] //存储去重后数组
				arr.forEach(function (item) {
					if (newArr.indexOf(item) == -1) {
						newArr.push(item)
					}
				})

				console.log(newArr)
			}

思路2: 利用双重for循环+splice实现，外层循环遍历数组所有元素，内层循环依次判断后面元素是否与外层循环元素相同，如果相同，截取掉

                function test3() {
				var arr = [2, 2, 2, 5, 2, 8, 2, 5]
                  //       0  1  2  3  4  5
                 //       [2, 2, 5, 2, 8, 2, 5]
                  //             2
				for (var i = 0; i < arr.length; i++) {
                    var item = arr[i] // 外层循环元素

					for (var j = i + 1; j < arr.length; j++) {
                        if(item == arr[j]){
                            arr.splice(j,1)
                            j--   //如果存在连续三个重复，就要j--来优化
                        }
                    }
				}
                console.log(arr)
			}
            test3()

练习：对一组学生的百分制成绩[98,78,89,77,69,59,85,100,93,81]， 分别统计出100分、90~99分、80~89分、…0~9分的人数。 

function getNumberByScore() {
	var stuScores = [98, 78, 89, 77, 69, 59, 85, 100, 93, 81]
	//定义一个存储各分数段人数的数组长度为11,初始值为0
	var num = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
	for (var i = 0; i < stuScores.length; i++) {
		var score = parseInt(stuScores[i] / 10) // 9
        num[score]++   //对应下标个数增加
     }
	for (var j = 0; j < num.length; j++) {
		if (j == 10) {
			console.log('100分人数 ' + num[j])
		} else {
			console.log(j * 10 + '-' + ((j + 1) * 10 - 1) + '分人数 ' + num[j])
		}
	}
}
getNumberByScore()

字符串

---

创建字符串对象

字面量：var str = '申鹤'     

构造函数方式  ：var str = new String('申鹤')   //String是属性

字符串的组成 

 字符串是由一系列字符构成，每个字符对应自己的下标，和数组类似，从0开始

访问字符串

str[0]     

不能赋值 str[0] = 'k' => 错误 

字符串长度 

str.length 

字符串遍历 

为什么字符串不是复杂数据类型，但可以使用属性和方法？

包装类型： 当使用点语句调用属性和方法时，自动转为复杂数据类型，使用完又转为基本数据类型。  （对象才可以调用属性和方法，点语句就是转）

基本数据类型            复杂数据类型
 string      ->         String  
                       str.length
number       ->         Number

89.888888    ->         num.toFixed(2)
boolean      ->          Boolean

常用方法 

---

chart

作用 : 根据下标返回字符

语法：str.chart()

indexOf  & lastIndexOf

作用 : 根据字符返回对应的下标的位置，如果字符不存在，返回-1

语法：str.indexOf()

        console.log('str.indexOf :',str.indexOf('l'))
        console.log('str.lastIndexOf :',str.lastIndexOf('l'))

substring

作用 : 截取字符串，包含开始索引，结束索引（不包括）

语法：str.substring(index,index)

        console.log( 'substring ', str.substring(1,3)  )
        var arr = ['h','e','l','l','w','o','r','l','d']
        var newArr = arr.slice(1,3)
        console.log('newArr :', newArr)

substr

作用 : 和splice相同，

语法：str.substr(index,个数)

        console.log('substr :', str.substr(1,3))
        var newArr1 = arr.splice(1,3)
        console.log( 'splice :',  arr ,'newArr1 ', newArr1)

replace

作用 : 后者替换前者，需要变量来接收

语法：str.replace('被替换','来替换的')

split

作用 :分割字符，返回数组

语法：str.split('-')      // 看到 - 就分割 将分割内容全放进数组

concat

作用 :拼接两字符串，返回连接之后的字符串

语法：str.concat('')    //str与''拼接

trim

作用 : 去掉空格，产生新的字符串

语法：var newStr = str.trim()

startsWith & endsWith

作用 : 判断字符串是否以子串开头  &  判断字符串是否以子串结尾

语法：str.startsWith('子串')  &   str.endsWith('子串')

toLowerCase & toUpperCase

作用 : 将str转成小写  &  将str转成大写

语法：var newStr = str.toLowerCase()  &  var newStr = str.toLowerCase()