js第九课——排序与简单认识对象

排序补充

冒泡排序
例：
    var arr = [1,4,7,2,123,45,78,23,59,5,176,13];
    // 冒泡排序         比较相邻两项大小，交换位置
    {
        for ( let i = 0 ; i < arr.length ; i ++ ) {
            for ( let j = 0 ; j < arr.length ; j ++ ) {
                //升序，从小到大排列
                if ( arr[j] > arr[j+1] ) {    //比较当前项和它的下一项的大小，如果当前项比它的下一项大
                   //交换
                    let temp = arr[j+1] ;     //下一项赋值给临时temp存储，然后交换两个键值
                    arr[j+1] = arr[j] ;        
                    arr[j] = temp ;
                }
                //  //降序，从大到小排列
                // if ( arr[j] < arr[j+1]) {  //比较当前项和它的下一项的大小，如果当前项比它的下一项小
                //     //交换
                //     let temp = arr[j+1] ;     //下一项赋值给临时temp，然后交换两个键值
                //     arr[j+1] = arr[j] ;        
                //     arr[j] = temp ;
                // }
            }
        }
        console.log(arr);                   //打印这个数组
    }
冒泡排序
例：
{
    for ( let j = 0; j < arr.length - 1; j ++ ) {
        let minIndex = j ;                              //假定数组第一个是最小值，将其键名赋值给minIndex
        //let maxIndex = j ;                            //假定数组第一个是最大值，将其键名赋值给maxIndex
        for ( let i = 1 + j; i < arr.length; i ++ ) {   //从假定最小值的后面一个元素开始
            //升序   从小到大进行排列
            if ( arr[i] < arr[minIndex] ) {             //比较它们的大小
                minIndex = i;                           //记录最小值所在的索引位置
            }
            //降序   从大到小进行排列
            if (arr[i] > arr[minIndex]) {               //比较大小
                minIndex = i;                           // 记录最大值的索引位置；      
            }
        }   
        let temp = arr[j];                              //声明一个临时变量存储
        arr[j] = arr[minIndex];                         //交换两个值
        arr[minIndex] = temp;                           
        //let temp = arr[j];                        
        //arr[j] = arr[maxIndex];
        //arr[maxIndex] = temp;
    }
    console.log(arr);
}
	/**
	 * @param{Array} arr
	 * 计数排序
	 * 返回的结果为计数排序之后的升序新数组
	 */
	 function countSort( arr ) {
	    var newArr = [] ; 
	    for( let i = 0 ; i < arr.length ; i ++ ) { 
	        if( newArr[arr[i]] == undefined ) {
	            newArr[arr[i]] = 1 ; 
	        } else {
	            newArr[arr[i]] ++ ;
	        }
	    }
	    var newArr2 = [] ;
	    for( let i = 0 ; i < newArr.length ; i ++ ){        //这里改变降序还是升序，正序升倒序降
	        if ( newArr[i] !== undefined ) {
	            for( let j = 1 ; j <= newArr[i] ; j ++ ){
	                newArr2.push(i);
	            }
	        }
	    }
	    return newArr2 ;     
	}

	/**
	 * 冒泡排序
	 * @param{Array} arr
	 * 返回值为排序后的原数组
	 * 升序排列
	 */
	function bubSort( arr ) {
	    for ( var i = 0 ; i < arr.length ; i ++ ){
	        for ( var j = 0 ; j < arr.length - 1 ; j ++ ){
	            if ( arr[j] > arr[j+1] ) {              //控制升序还是降序   > 升   < 降
	                var temp = arr[j] ; 
	                arr[j] = arr[j + 1] ;
	                arr[j + 1] = temp ;
	            }
	        }
	    }
	    return arr ;
	}

	/**
	 * 选择排序
	 * @param{Array} arr 
	 * 选择排序
	 * 返回值是升序排列的原数组
	 */
	function selectSort( arr ){
	    for ( var i = 0 ; i < arr.length ; i ++ ) {
	        var minIndex = i ;
	        for ( var j = i ; j < arr.length ; j ++ ) {
	            if ( arr[minIndex] > arr[j] ) {         //控制升序与降序  > 升   < 降
	                minIndex = j ; 
	            }
	        }
	        var temp = arr[minIndex] ;
	        arr[minIndex] = arr[i] ; 
	        arr[i] = temp ;
	    }
	    return arr ; 
	}

复杂数据类型与堆栈

在js里，简单数据类型会存放在栈里，复杂数据
类型的值会存在堆里，在栈里存放复杂数据类型
的堆地址

--注--
    复杂数据类型的比较会比较数据在内存堆中的地址和值
    复杂数据类型直接赋值，赋的是复杂数据类型存储在栈中的地址

复杂数据类型相互引用问题

--注--  我们可以用typeof判断简单的数据类型，数组和对象数据类型，用typeof方法判断不够精确。
        数组和对象  typeof arr 和typeof obj 都是object类型

这里我们可以用Array.isArray();判断是否为对象，返还值是Boolean类型的true或者false

深度拷贝

为什么要深度拷贝？
在内存中，js复杂数据类型的值存放在堆里，在内存栈中用一个地址值指向这个堆。当我们复杂数据类型直接赋值时，我们实际上复制的是
复杂数据类型在栈中地址，我们改变新数据会对原来对象数据产生影响，这个时候就需要我们深度拷贝。

1.简单的深度拷贝
    var newObj = JSON.parse(JSON.stringify(数组名或者对象名)) ; 
    JSON.stringify();方法会将对象类型变成字符串，然后再由JSON.parses()解析出来
    缺点：该方法会忽略函数fn类型和未定义undefined类型
2.使用递归进行深度拷贝
    function DeepCopy( arg ) {
        if ( Array.isArray(arg) ) {
            var newArg = [] ;
        } else {
            var newArg = {} ; 
        }
        for ( var key in arg ) {
            if ( typeof arg[key] != "object" ){
                newArg[key] = arg[key] ; 
            } else {
                newArg[key] = DeepCopy(arg[key]) ;
            }
        }
        return newArg ; 
    }
    运用递归函数实现简单深度拷贝

this关键字

this是js预定义的关键字。

this关键字的用法

1.全局this
    全局this会指向一个全局预定义对象window。window是全局的，一般可以忽略
    例：    var  console.log(this); //打印结果为window
2.函数里的this指向 ———— 定义的时候不能确定
    调用的时候：
        a.直接调用 this ，指向window
            例：    function fn (){
                        console.log(this);
                    }
                    fn();  //这里打印的结果window

        b.放在对象里调用，如果调用的方式是 对象.函数名() ; 那么this指向调用函数的对象
            例：    var obj = {
                        name:"liLei",
                        fn:function(){
                            console.log(this);
                        }
                    }
                    obj.fn();  //这里打印的是obj对象

        c.放在对象里，但是调用的方式是通过全局变量接收后再调用；那么this就指向window
            例：    var obj = {
                        name:"liLei",
                        fn:function(){
                            console.log(this);
                        }
                    }
                    var myFn = obj.fn ; 
                    myFn();       //打印的结果为window

严格模式

    1.严格模式的开启
        "use strict"
    2.严格模式下this的不同
        在严格模式下，直接调用函数this，打印结果为undefined

字符串方法

1.根据字符串的键名获取键值  charAt
    例：    var str = "adsjahf" ; 
            console.log(str.charAt(2)); //打印结果为s,和str[键名]效果一样

2.根据字符串的下标获取键值的ASCII码
    例：    var str = "adsjahf" ; 
            console.log(str.charAtCode(0)); //打印结果为97,结果时十进制字符a的ASCII码
3.查找字符串里是否含有某个字符  indexOf 

4.字符串截取 substring 
    例:     var str = "abcdefg" ; 
            var str1 = str.substring(0,3);
            console.log(str1); //abc
            第一个参数表示开始截取的位置；第二个参数表示结束截取位置，如果不写，会截取到后面所有的元素
        --注--      该方法截取时，包括前面元素，不包括后面元素
5.字符串截取 substr();
    例：    var str = "abcdefg" ; 
            var str1 = str.substr(0,3);
            console.log(str1); //abc
            第一个参数表示截取的位置；第二个参数表示截取元素的个数，如果不写，默认截取到后面所有字符
6.替换字符 replace();
    例： var str = "accdef" ;
        var res = str.replace("c","b");
        console.log(res);   //打印结果为abcdef
        replace方法，一次只能替换一个字符，方法中，第一个参数是被替换的字符，第二个参数是替换后的字符