var findTargetIn2DPlants = function (plants, target) {
  //特殊情况判断，空数组，return false
  if (plants.length === 0) return false;

  const r = plants.length;
  const c = plants[0].length;
  // 通过i,j确定根节点为右上角
  let i = 0;
  let j = c - 1;
  // 从右上角开始查找
  while (i < r && j >= 0) {
    if (plants[i][j] === target) {
      return true;
    } else if (plants[i][j] > target) {
      j--;
    } else {
      i++;
    }
  }
  return false;
};

//没写出来
var findMin = function(nums) {
    // 特点在于，目标数的前一位大于目标数
    //特殊情况是目标数的下表为0，说明旋转了0次
    let left = 0,right = nums.length
    while(left<right){
        let mid = left + Math.floor((right - left)/2)
        if(mid === 0) return nums[mid]
        else{
            if(nums[mid] < nums [mid-1]) return nums[mid]
            else if()
        }

    }
};

var stockManagement = function(stock) {
  let low = 0;
    let high = stock.length - 1;
    while (low < high) {
        const pivot = low + Math.floor((high - low) / 2);
        if (stock[pivot] < stock[high]) {
            high = pivot;
        } else if (stock[pivot] > stock[high]) {
            low = pivot + 1;
        } else {
            high -= 1;
        }
    }
    return stock[low];
};

var trainWays = function(num) {
  //和爬楼梯很像，是动态规划的题目
  //dp[i]表示跳到第i个台阶的方法数
  let dp = new Array(num + 1).fill(0)
  dp[0] = 1
  dp[1] = 2
  //这里有一些特殊情况，第一种是在程序提交不同过的例子中发现的，
  if (num === 0) return dp[0]
  //第二种就是只有一个格子
  if (num === 1) return dp[0]
  //第三种只有两个格子的情况。
  if (num === 2) return dp[1]
  else {
    for (let i = 2; i < num; i++) {
      //别忘了题目要求的取模
      dp[i] = (dp[i - 1] + dp[i - 2]) % 1000000007
    }
    return dp[num - 1]
  }
};

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number}
 */
var findMedianSortedArrays = function(nums1, nums2) {
  // 保证nums1的较短数组
  if (nums1.length > nums2.length) {
    [nums1, nums2] = [nums2, nums1];
  }
  //m为较短数组的长度,n为较长数组的长度
  let m = nums1.length; // Add missing variable declaration for m
  let n = nums2.length; // Add missing variable declaration for n
  // 左边元素的个数
  let totalLeft = Math.floor((m + n + 1) / 2);
  // 在nums1的[0,m]中找合适的分割线
  // 使得nums1[i-1] <= nums2[j] && nums2[j-1] <= nums1[i]
  let left = 0, right = m;
  // 二分查找
  while(left < right){ // Fix the loop condition
    let i = left + Math.floor((right - left + 1) / 2);
    let j = totalLeft - i;
    if(nums1[i-1] > nums2[j]){
      //下一轮搜索区间在[left,i-1]
      right = i-1;
    }
    else{
      //下一轮搜索区间在[i,right],注意当这个区间只有两个元素时，会陷入死循环，因此在二分的时候要+1
      left = i
    }
  }
  //退出循环后找到了想要的分割线
  let i = left;
  let j = totalLeft - i;
  // 定义左右两边的四个值,还是为了适应特殊情况
  // 如果 i 等于 0，说明 nums1 的左侧没有元素，所以左侧最大值设为负无穷 -Infinity。否则，左侧最大值就是 nums1[i-1]。
  //左侧找最大值，右侧找最小值
  let nums1LeftMax = i === 0 ? -Infinity : nums1[i-1];
  let nums1RightMin = i === m ? Infinity : nums1[i];
  let nums2LeftMax = j === 0 ? -Infinity : nums2[j-1];
  let nums2RightMin = j === n ? Infinity : nums2[j];
  // 如果总长度是奇数
  if((m + n) % 2 === 1){
    return Math.max(nums1LeftMax, nums2LeftMax);
  }
  else{
    return (Math.max(nums1LeftMax, nums2LeftMax) + Math.min(nums1RightMin, nums2RightMin)) / 2;
  }
};

const obj = {
  a:1,
  b:2,
  c:{
    d:3,
    e:4
  },
}
function _isObject(v){
  return typeof v==='object' && v != null
}
function observe(obj){
  for(const k in obj){
    let v = obj[k]
    if (_isObject(v)){
      observe(v)
    }
    Object.defineproperty(obj,'a',{
    get(){
      console.log('a','读取')
      return v
    },
    set(newval){
      if(v != newval){
        v = newval
        console.log('a','更改')
      }
    }
  })
  }
}

const obj = {
  a:1,
  b:2,
  c:{
    d:3,
    e:4
  },
}
function _isObject(v){
  return typeof v==='object' && v != null
}

function observe(obj){
  const proxy = new Proxy(obj,{
    get(target,k){
      let v = target[k]
      if(_isObject(v)){ //这里是有递归，但只有v被读到才会触发。
        observe(v)
      }
      console.log(k,'读取')
      return v
    },
    set(target,k,val){
      if(target[k] != val){
        target[k] = val
      }
    }
  })
  return proxy
}

const proxy = new Proxy(obj,{
  get(target,k){
    let v = target[k]
    console.log(k,'读取')
    return v
  },
  set(target,k,val){
    if(target[k] != val){
      target[k] = val
    }
  }
})

// 方法一：遍历数组，splice删除重复项
var removeDuplicates = function(nums) {
  for(let i = 0; i<nums.length; i++){
    let j = i+1
    while(nums[i] == nums[j]){
      nums.splice(i, 1)    //我一直再写j++，其实没必要，因为数据已经被删除了
    }
  }
};

//方法二：双指针
var removeDuplicates = function(nums) {
  let p=0,q=1   //前后指针
  while(q<nums.length){
    if(nums[p] != nums[q]){
      nums[p+1] = nums[q]
      p++
    }
   q++
  }
  return p+1
};

pnpm install -D vite-plugin-mock mockjs

import { UserConfigExport, ConfigEnv } from 'vite'
import { viteMockServe } from 'vite-plugin-mock'
import vue from '@vitejs/plugin-vue'
export default ({ command })=> {
  return {
    plugins: [
      vue(),
      viteMockServe({  //保证开发期间可以使用访问mock提供的数据
        localEnabled: command === 'serve',
      }),
    ],
  }
}

//用户信息数据
//createUserList函数执行会返回一个数组，数组里面包含两个用户信息
function createUserList() {
    return [
        {
            userId: 1,
            avatar:
                'https://wpimg.wallstcn.com/f778738c-e4f8-4870-b634-56703b4acafe.gif',
            username: 'admin',
            password: '111111',
            desc: '平台管理员',
            roles: ['平台管理员'],
            buttons: ['cuser.detail'],
            routes: ['home'],
            token: 'Admin Token',
        },
        {
            userId: 2,
            avatar:
                'https://wpimg.wallstcn.com/f778738c-e4f8-4870-b634-56703b4acafe.gif',
            username: 'system',
            password: '111111',
            desc: '系统管理员',
            roles: ['系统管理员'],
            buttons: ['cuser.detail', 'cuser.user'],
            routes: ['home'],
            token: 'System Token',
        },
    ]
}

export default [
    // 用户登录接口
    {
        url: '/api/user/login',//请求地址
        method: 'post',//请求方式
        response: ({ body }) => {
            //获取请求体携带过来的用户名与密码
            const { username, password } = body;
            //调用获取用户信息函数,用于判断是否有此用户
            const checkUser = createUserList().find(
                (item) => item.username === username && item.password === password,
            )
            //没有用户返回失败信息
            if (!checkUser) {
                return { code: 201, data: { message: '账号或者密码不正确' } }
            }
            //如果有返回成功信息
            const { token } = checkUser
            return { code: 200, data: { token } }
        },
    },
    //对外暴露一个数组，
    //数组中包含登录假接口
    //还有一个获取用户信息得到假的接口
    {
        url: '/api/user/info',
        method: 'get',
        response: (request) => {
            //获取请求头携带token
            const token = request.headers.token;
            //查看用户信息是否包含有次token用户
            const checkUser = createUserList().find((item) => item.token === token)
            //没有返回失败的信息
            if (!checkUser) {
                return { code: 201, data: { message: '获取用户信息失败' } }
            }
            //如果有返回成功信息
            return { code: 200, data: {checkUser} }
        },
    },
]

//定义一个对象
var obj = {
  name: '张三',
  age : 20
}

object.defineProperty(obj,name){
  get:function(){
    console.log('有人读取了name属性')
    return obj.name
  }
  set function(val){  //obj中的name发生那个变化后，会调用set函数。因此可在这里调用其依赖函数
    obj.name = val
    console.log('有个家伙在给name属性赋值')
  }
}

//方法一：Set集合，可以判断，如果当前的值和之前的值相同，则不执行依赖函数
let funcs = new Set()
//方法二：ES6中的includes方法，判断当前的值是否在数组中，如果在，则不执行依赖函数
let funcs = []
if (!funcs.includes(func)) {
  funcs.push(func)
}

// 不直接运行函数，而是使用定义一个全局变量，这样只要使用这个统一变量的名称运行函数，就能拿到函数了
window.__func = func1
  func1()
window.__func = null
//这样只需在get中添加window.__func到数组即可

//首先新建一个js，在这个新的js中实现上述代码
//定义一个观察者，监视对象的属性
function Observer(obj) {
  for (const key in obj){
    let intervalValue = obj[key]
    let observers = new Set()    //用来保存相关依赖
    //使用Object.defineProperty()方法，给obj的key属性添加get和set方法
    defineProperty(obj, key, obj[key]){
      get: function(){
        if (window.__func){  //存在说明有函数在运行，是哪个函数呢，那个函数名使用window.__func可以访问到
          observers.add(window.__func)
        }
        return intervalValue
      },
      set: function(val){
        console.log('有人修改了' + key + '属性，我要去通知我的订阅者了')
        obj[key] = val
        //通知所有的订阅者,重新运行
        observers.forEach(observer => observer())
      }
    }
  }
}

// 定义一个统一执行函数的函数
function autoRun(fn){
window.__func = fn
fn()
window.__func = null
  }

//函数调用时用autoRun不要直接运行
autoRun(func1())
autoRun(func2())