函数相关

函数

    <!-- 对于js来说，函数就是把任意一段代码放在一个盒子里面
    在我想要让这段代码执行的时候，直接执行中个盒子里面的代码就行-->

    <!--  定义函数-->
    <!-- 声明式
    function test1(){
        console.log("xxxx")
    }   
    声明式定义的函数可以先调用后，声明
    -->
<!-- 
tese1() 此处直接就调用函数


    <!--  赋值式-->
    <!-- var tese2 = function{ -->
       <!-- console.log(xxxx)
    } -->
    <!-- tese2() 一样如此先调用
    必须先定义/赋值函数，才可以调用 --> -->

关于函数的案列

// }
// fn(实参写这里)
function tese(a,b){
    var yingliao = a===1?'可乐':'雪碧'
    var  xiaochi = b===1?'薯条':'鸡米花'
    var  zhushi = "鸡腿堡"
    console.log("我是套餐A ",yingliao,xiaochi,zhushi)
}
    tese(1,1)

三目预算符

    age>=18? alert('已成年'):alert('未成年')

与swtich类似，但是比较方便，可以直接写个一个语句中个人认为比swtich好使

对象

        // var nickName，age，gendr，locati，into
                // var obj ={
        //     name: "yanjie",
        //     age : 19,
        //     location:"赣州"
        // } 
        // console.log(obj)

        // 内置构造函数

        // var obj2 = new Object()
        // console.log(obj2)

        // obj2.name = "xiaoming"
        // obj2.age = 18
        // console.log(obj2)


        var obj3 = {}
        obj3.name = "洁哥"
        obj3.age = "19"
        document.write("姓名是："+obj3.name) //  用这样的方式查询
        
        // 改 obj3.name = xxx 前面的名称要一致才能覆盖，否则是增加
        // 删除 delete obj3.name     关键值
        // 2-增 var obj3 = {}
        //  obj3["name"] = "jege"
        // 改 obj3["name"] = "sdsdwd"
        // delete obj3["name3"]

对象的表现形式是以 {} 数组是以 [] 对象的遍历

            name : "jiege",
            age : 100,
            location: "ganzhou"
        }

// key“ ： ”是前面的值，value是 ： 后面的值

        for(var i in obj){
            // console.log(i)
            // 获取的是key
            // console.log(obj[i])
            // 获取value值
            document.write(i+":"+obj[i])
            document.write("<br>")
            
        

数组

        var ageArr = [12,14,15,16]
        var nameArr = ["jiege","xm","xy","zy"]
        console.log(ageArr)

        // length 可读可写


        // 内置构造函数  Array  创建数组
        
        var arr1 = new Array()
        // 创建一个空数组
        var arr10 = new Array()
        // 创建一个长度为10的数组
        var arr3 = new Array(1,2,3)
        // 创建一个有内容的数组
        arr3.length = 2
        // 改变数组的长度，从后往前减

        console.log(arr3)

        // 索引
        
        console.log(nameArr[0])
        // 改变原来数组中的元素
        nameArr[0] = "wuyanjie"
        // 若改变原来数组在[x]x大于原本数组长度，则为增长数组


        // 数组的遍历
        var arr4 = [1,2,3,4]
        // for(i = 0;i<arr4.length;i++){
        //     console.log(arr4[i])
        // }

          // 数组的复制

          var arr5 = []
            for(var i =0;i<arr4.length;i++){
                arr5[i]=arr4[i]
            }
            console.log(arr5)

            arr5[5]=10

冒泡排序法，利用数组等性质

        // var arr =[6,8,1,2,4,7]
        // var temp = arr[0]
        // arr[0] = arr[1]
        // arr[1] = temp
        // console.log(arr)

        // for (var i = 0; i < arr.length - 1; i++) {
        //     if (arr[i] > arr[i + 1]) {
        //         var temp = arr[i]
        //         arr[i] = arr[i + 1]
        //         arr[1 + 1] = temp
        //     }
        // }


        // for (m = 0; m < arr.length - 1; m++) {
        //     for (var i = 0; i < arr.length-1-m; i++) {
        //         if (arr[i] > arr[i + 1]) {
        //             var temp = arr[i]
        //             arr[i] = arr[i + 1]
        //             arr[i + 1] = temp
        //         }
        //     }
        // }
        // console.log(arr)冒泡排序


        // 选择排序

        var  arr = [44,1,2,9,10,11]
     
        // for(var i=1;i<arr.length;i++){
        //     if(arr[i]<arr[minIndex]){
        //         minIndex = i
        //     }
        // }
        // var temp = arr[0]
        // arr[0] = arr[minIndex]
        // arr[minIndex]=temp
        // console.log(arr)

        for(var m=0;m<arr.length-1;m++){
            var minIndex = m
            for(var i=1+m;i<arr.length;i++){
            if(arr[i]<arr[minIndex]){
                minIndex = i
            }
        }
           if(i!==m){
            var temp = arr[m]
            arr[m] = arr[minIndex]
            arr[minIndex] = temp
           }
        
        }
        console.log(arr)

数组的常用性质

`` var arr = [1,2,3]

    // push后面追加元素
    // 返回值 长度
//   arr.push(2)

    // pop 后面删除元素
        // 放回值是删除的元素

        // unshift 前面追加元素
        // 返回值 长度

        // shift 前面删除元素
        // 放回值前面删除的元素

        // var resunshift = arr.unshift("洁哥")
        // console.log(arr)
        // console.log("返回值",resunshift)

        // splice 删除
       
//  var ressplice = arr.splice(1,1,xxx,xxx)// 第一个1是从第一个索引开始删除,第二个是删几个元素
    // 往后面补充元素,可以加元素 如果为(0,0,xx,xx)意为,从第零个开始加元素
//  console.log("返回值",ressplice)
//     console.log(arr)

        // 增加


        // reverse 倒叙
        // var arr3 = [1,2,3,4]
        // arr3.reverse()
        // console.log(arr3)
        // 注意,假如原始数据并未按照从大到小的顺序进行排列,则倒叙也不会按照从小到大的顺序进行排列

    // sort 排序
        // var arr4 = [11,12,56,7,3]
        // arr4.sort(function(x,y){

        //     return x-y
    
        // })
        // console.log(arr4)
        // x-y为正序,x+y为逆序

        // 数组去重
        var arr7 = [22,22,24,30,27]
        var set1 = new Set(arr7)
        console.log(set1)
        // Set直接将重复的数组进行删除

        var arr8 = Array.from(set1)

        console.log(arr8)

``

数组的值改变和引用，分为改变原来的值和不改变原来的值，下组代码为不改变原来值的几个示例

        var arr2 = [4,5,6]

        // var arr3= arr1.concat(arr2,7)
        // 也可以在后面穿其他的参数,添加一个逗号后即可

        // var arr4 = arr1.concat() 可以为为新的复制方式

        // join 数组转化为字符串
        // console.log(arr3)

        // var arr = [1,2,3,4,5]

        // document.write(arr.join(""))
// slice 截取（开始索引，结束索引） 包前不包后
// （2）从第二个下标开始到最后
        // var arr3 = [ "aaa","bbb",'ccc']
        // var arr4 = arr3.slice(0,2)
        // console.log(arr3,arr4)

        // indexof
        // 返回值为 -1时候表示找不到，不存在该元素  返回值为0的时候表示存在该元素且存在多个一样的
        // (X,1)从第几个开始往后面找x元素
        // var res = arr1.indexOf(2)
        // console.log(res)

        // lastIndexOf("xxx",3)从第几个往前面找