let a = [1,2,3,[4,5]]
let b = Json.parse(Json.stringify(a))

let obj = {
name:"Tom",
age:18,
fn(){
console.log("age:",this.age)
},
tt:{project:"kkk"},
aa:[1,2,3]
}

let obj2 = {...obj} // 淺拷貝：只復(fù)制第一層屬性值（如字符串、數(shù)字等），對于嵌套的對象或數(shù)組，復(fù)制的是引用地址
obj.fn = function(){
console.log("++age:",++this.age)}

obj.fn()
obj2.fn()

obj.tt.project = "yyy"
console.log("obj",obj.tt.project)
console.log("obj2",obj2.tt.project)

obj.aa[0] = 5
console.log("obj",obj.aa)
console.log("obj2",obj2.aa)

let a = [1,2,3]
console.log(typeof a) //object

let b=null
console.log(typeof b)//object
let c=undefined
console.log(typeof c)//undefined

/**
 * 深拷貝函數(shù)：遞歸實現(xiàn)
 * @param {any} oldData 需要拷貝的數(shù)據(jù)，可以是對象、數(shù)組或基本類型
 * @return {any} 返回拷貝后的新數(shù)據(jù)，與原數(shù)據(jù)無引用關(guān)系
 */
function deepClone(oldData) {
  // 判斷當(dāng)前處理的數(shù)據(jù)是否為對象類型，并且不是 null（因為 typeof null === 'object'）
  if (typeof oldData === 'object' && oldData != null) {
    // 根據(jù)原始數(shù)據(jù)是數(shù)組還是對象創(chuàng)建一個新的空數(shù)組或空對象作為結(jié)果容器
    let res = Array.isArray(oldData) ? [] : {};

    // 遍歷原始對象的所有自有屬性（不包括繼承來的屬性）
    for (let k in oldData) {
      if (oldData.hasOwnProperty(k)) {
        // 對當(dāng)前屬性值遞歸調(diào)用 deepClone 函數(shù)進行深拷貝
        // 并將返回的結(jié)果賦值給結(jié)果對象/數(shù)組對應(yīng)的鍵
        res[k] = deepClone(oldData[k]);
      }
    }

    // 返回已經(jīng)完成深拷貝的對象/數(shù)組
    return res;
  } else {
    // 如果當(dāng)前數(shù)據(jù)是基本類型（如 number, string, boolean）或者函數(shù)等，則直接返回原值
    // 因為基本類型在賦值時是值傳遞，不會產(chǎn)生引用問題
    return oldData;
  }
}

const original = {a:1, b: {c:2}, d:new Date()};
const deepCopy = structuredClone(original)

deepCopy.b.c = 20; 

console.log(original.b.c)  //2
console.log(original.d.getTime() === deepCopy.d.getTime()) //true (Date被正確克隆了)

var arr = [3,4,1,6,4]//準備好一個數(shù)組
 
var arr2 = arr.concat()//concat合并方法
 
var arr4 = JSON.parse(JSON.stringify(arr))//用JSON方法轉(zhuǎn)換
 
var arr5 = arr.slice(0)//slice拷貝方法
 
var [...arr6] =arr;//擴展運算符方法
 
var arr7 = copyArr(arr)//萬能的for循環(huán)
    function copyArr(arr){
        let res = []
        for(let i=0;i<arr.length;i++){
            res.push(arr[i])
        }
        return res 
    }
 
 
//冒泡排序 
   for(var j = 0;j<arr.length-1;j++){//// 遍歷數(shù)組，arr.length - 1表示要遍歷的次數(shù)
       for(var i = 0;i<arr.length-1-j;i++){
        // i<arr.length-1-j 是因為當(dāng)?shù)谝淮?，找到最大?shù)，放到最后，那么下一次，遍歷的時候就不用吧最后一位算上，因為他已經(jīng)是最大的
            var done = true;//設(shè)置一個標(biāo)志位，減少不必要的循環(huán)
            if(arr[i]>arr[i+1]){//當(dāng)前數(shù)字大于后一位數(shù)組 位置調(diào)換
                var temp = arr[i]
                arr[i] =arr[i+1]
                arr[i+1] = temp
                done = false
                
            }
        }
        if(done){//調(diào)換位置后跳出本次循環(huán) 
           break;//減少不必要的排序，提高性能。
        }
   }
//冒泡排序思想：每一次對比相鄰兩個數(shù)據(jù)的大小，小的排在前面，如果前面的數(shù)據(jù)比后面的大就交換這兩個數(shù)的位置
console.log('經(jīng)過排序的原數(shù)組：'+arr)
console.log('concat方法：'+arr2)
console.log('轉(zhuǎn)換為json再轉(zhuǎn)為對象：'+arr4)
console.log('slice方法：'+arr5)
console.log('ES6擴展運算符方法：'+arr6)
console.log('萬能的for方法：'+arr7)

var obj = {
  name: 'wayne',
  sex: 'man',
  old: '23'
}
var obj2 = copyObj(obj)
function copyObj(obj) {
  let res = {}
  for (var key in obj) {
    res[key] = obj[key]
  }
  return res
}

var obj = {
  name: 'wayne',
  sex: 'man',
  old: '23'
}
var obj2 = JSON.parse(JSON.stringify(obj))
//原理沒什么好解釋的，實在是夠簡單粗暴

var obj = {
  name: 'wayne',
  sex: 'man',
  old: '23'
}
var { ...obj2 } = obj