/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */

var swapPairs = function(head) {
    if(head === null ||head.next ===null){
        return head
    }
    const newhead = head.next;
    head.next = swapPairs(newhead.next)//连接第一个和第三个
    newhead.next = head;//连接第二个和第一个
    return newhead
};

/*
@Date		:2023/11/12 21:50:47
@Author		:zono
@Description:链表设置
*/
function ListNode(val, next) {
  this.val = val === undefined ? 0 : val;
  this.next = next === undefined ? null : next;
}

// 创建链表节点
const node1 = new ListNode(1);
const node2 = new ListNode(2);
const node3 = new ListNode(3);
const node4 = new ListNode(4);

// 构建链表关系
node1.next = node2;
node2.next = node3;
node3.next = node4;

var swapPairs = function (head) {
  const dummyHead = new ListNode(0);
  dummyHead.next = head;
  let temp = dummyHead;//这里需要思考深浅拷贝
  while (temp.next !== null && temp.next.next !== null) {
    const node1 = temp.next;
    const node2 = temp.next.next;
    temp.next = node2;
    node1.next = node2.next;
    node2.next = node1;
    temp = node1;
  }
  return dummyHead.next;
};

function sort(currentNode) {
  while (currentNode !== null) {
    console.log(currentNode.val);
    currentNode = currentNode.next;
  }
}

sort(swapPairs(node1));

const onFinish = async (values) =>  {
  //一个固定的读取表单的函数
  console.log( values);
  // 触发请求
  await dispatch(fetchLogin(values))
  // 登录成功后跳转首页，并提示用户（避免异步）
  navigator('/') 
  message.success('登录成功')
}

const fetchLogin = (loginForm) => {
  /*
  @Description: 异步请求获取token,并返回应该promise函数
  */
  const { username, password } = loginForm;
  const requestData = {
    grant_type: "",
    username,
    password,
    scope: "",
    client_id: "",
    client_secret: "",
  };
  return (dispatch) => {
    //分布异步请求，并存入
    const res = request({
        url: '/token',
        method: 'POST',
        data: formData,
        headers: {
          'accept': "application/json",
          "Content-Type": "application/x-www-form-urlencoded",
        },
      })
    dispatch(setToken(res.data.access_token));
  };
};

const fetchLogin = (loginForm) => {
  /*
  @Description: 异步请求获取token,并返回应该promise函数
  */
  const { username, password } = loginForm;
  const requestData = {
    grant_type: "",
    username,
    password,
    scope: "",
    client_id: "",
    client_secret: "",
  };
  return async (dispatch) => {
    //分布异步请求，并存入
    const res = request({
        url: '/token',
        method: 'POST',
        data: formData,
        headers: {
          'accept': "application/json",
          "Content-Type": "application/x-www-form-urlencoded",
        },
      })
    dispatch(setToken(res.data.access_token));
  };
};

const fetchLogin = (loginForm) => {
  /*
  @Description: 异步请求获取token,并返回应该promise函数
  */
  const { username, password } = loginForm;
  const requestData = {
    grant_type: "",
    username,
    password,
    scope: "",
    client_id: "",
    client_secret: "",
  };
  return async (dispatch) => {
    //分布异步请求，并存入
    const res = await loginAPI(requestData);
    dispatch(setToken(res.data.access_token));
  };
};

function loginAPI (formData){
    return request({
        url: '/token',
        method: 'POST',
        data: formData,
        headers: {
          'accept': "application/json",
          "Content-Type": "application/x-www-form-urlencoded",
        },
      });

function fun(){
	var f ={};
	var g ={};
	f.userName=g;
	g.userName=f
	//循环引用无法为零
}

<script>
    ....
    // 获取canvas对象
    const canvas = document.getElementById('canvas')
    // 获取渲染上下文对象
    const ctx = canvas.getContext('2d')
    ...
</script>

const oldObj = {
    name:'zono',
    colors:['orange','green','blue'],
    friend:{
        name:'童馨'
    }
}

const newObj = oldObj;
newObj.name = 'xiao';
console.log('oldObj',oldObj);
console.log('newObj',newObj);//输出相同都是xiao

function deepClone(obj){
  const newObj = {};
  let keys = Object.keys(obj);
  let key = null;
  let data = null;
  for(let i = 0; i<keys.length;i++){
    key = keys[i];
    data = obj[key];
    if(data && typeof data === 'object'){
      newObj[key] = cloneDeepDi(data)
    }else{
      newObj[key] = data;
    }
  }
  return newObj
}

function deepCopy(obj, parent = null) {
    // 创建一个新对象
    let result = {};
    let keys = Object.keys(obj),
        key = null,
        temp = null,
        _parent = parent;
    // 该字段有父级则需要追溯该字段的父级
    while (_parent) {
        // 如果该字段引用了它的父级则为循环引用
        if (_parent.originalParent === obj) {
            // 循环引用直接返回同级的新对象
            return _parent.currentParent;
        }
        _parent = _parent.parent;
    }
    for (let i = 0; i < keys.length; i++) {
        key = keys[i];
        temp = obj[key];
        // 如果字段的值也是一个对象
        if (temp && typeof temp === 'object') {
            // 递归执行深拷贝 将同级的待拷贝对象与新对象传递给 parent 方便追溯循环引用
            result[key] = DeepCopy(temp, {
                originalParent: obj,
                currentParent: result,
                parent: parent
            });

        } else {
            result[key] = temp;
        }
    }
    return result;
}

function cloneDeepAssign(obj){
  return Object.assign({},obj)
  //Object.assign({},obj)
}