const instance = axios.create({
    baseURL: 'https://api.example.com',
    timeout: 1000,
    headers: {
        'Content-Type': 'application/json'
    }
})


// 类似express中的app.use，可以做身份验证
instance.interceptors.request.use(
    function(config){
        const token=localStorage.getItem('token')
        if(token){
            config.headers.Authorization=`Bearer ${token}`
        }
        return config
    }
    function(error){
    	return Promise.reject(error)
	}
)

// 可以用来统一处理error日志，而不是在每个catch中处理
axios.interceptors.response.use(
  response => {
    // 处理成功的响应
    console.log('Response received:', response);
    // 例如统一处理数据格式
    if (response.data && response.data.data) {
      return response.data.data;
    }
    return response;
  },
  error => {
    // 处理错误的响应
    console.error('Error response:', error);
    // 例如统一处理错误信息
    if (error.response) {
      switch (error.response.status) {
        case 401:
          // 处理未授权错误
          console.error('Unauthorized');
          break;
        case 500:
          // 处理服务器错误
          console.error('Server error');
          break;
        default:
          console.error('Error status:', error.response.status);
          break;
      }
    }
    return Promise.reject(error);
  }
);

5=='5' // '5'会被转换为number 5
0 == false // false会被转换为0
null == undefined  // true，因为它们在不进行类型转换的情况下是相等的

null === undefined // false，因为类型不同，null是object类型，undefined是undefined
console.log(typeof a);  // 输出：object
console.log(typeof b);  // 输出：undefined

let L=console.log.bind(console)
let arr=[1,2,3,4]

L(arr.some(curr=> curr==2 || curr==3)) // true
L(arr.every(curr=> curr >0)) // true
L(arr.every(curr=> curr >1)) // false

let total=0
arr.forEach((v,i)=>{
    total+=v
})
L(total) // 10

L(arr.indexOf(4))
L(arr.find((curr=>curr>2))) // the first element that is bigger than 2 is 3

arr.unshift(9)
L(arr) // [9,1,2,3,4]
L(arr.toString()) // '9,1,2,3,4'
L(arr.join())

let arr1=arr.splice(1,4)
L(arr) // [9]
L(arr1) // [1,2,3,4] the element deleted

arr1.reverse()
L(arr1) // [4,3,2,1]

arr1.splice(2,0,10) 
L(arr1) // [4,3,10,2,1]

arr1.sort((a,b)=>{
    return a-b
})
L(arr1) // [1,2,3,4,10]

L(arr1.at(-1)) // 10

axios.get()
.then((data)=>{conolse.log(data)})
.catch((error)=>{console.log(error)})

Promise.all2 = (promises) => {
    return new Promise((resolve, reject) => {
        if (promises.length === 0) {
            resolve()
            return
        }
        if (promises.length !== 0) {
            let counter = 0
            let results = new Array(promises.length)
            for (let i = 0; i < promises.length; i++) {
                Promise.resolve(promises[i])
                    .then((value) => {
                        counter += 1
                        results[i] = value
                        if (counter == promises.length) {
                            resolve(results)
                        }
                    })
                    .catch(() => {
                        reject('出错了')
                    })
            }
        }

    })
}

const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve('foo')
    }, 100);
});

Promise.all2([promise1, promise2, promise3]).then(values => {
    console.log(values); // 预期输出: [3, 42, "foo"]
}).catch(error => {
    console.error(error);
});

const promise = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve(res);
    }, 1000);
});

promise.then((res) => {
    console.log(res);
}, (err) => {
    console.log(err);
});
promise.catch((err) => {
    console.log(err);
});
promise.finally(() => {
    console.log("finally over");
});

const FULFILLED = 'fulfilled'
const PENDING = 'pending'
const REJECTED = 'rejected'


function MyPromise(handler) {
    this.status = PENDING
    this.value = undefined
    this.onFulFilledCallbacks = []
    this.onRejectedCallbacks = []

    const resolve = (val) => {
        if (this.status === PENDING) {
            this.status = FULFILLED
            this.value = val
            this.onFulFilledCallbacks.forEach(f => f(val))
        }
    }

    const reject = (err) => {
        if (this.status === PENDING) {
            this.status = REJECTED
            this.value = err
            this.onRejectedCallbacks.forEach(f => f(err))
        }
    }

    try {
        handler(resolve, reject)
    } catch (error) {
        reject(error)
    }
}


MyPromise.prototype.then = function (onFulfilled, onRejected) {
    if (this.status === FULFILLED) {
        onFulfilled(this.value)
    } else if (this.status === REJECTED) {
        onRejected(this.value)
    } else {
        // pending
        this.onFulFilledCallbacks.push(onFulfilled)
        this.onRejectedCallbacks.push(onRejected)
    }
}

const p1 = new MyPromise((resolve, reject) => {
    setTimeout((v) => {
        resolve(v)
    }, 1000, 'ok')
})

const p2 = new MyPromise((resolve, reject) => {
    setTimeout((v) => {
        resolve(v)
    }, 1000, 'fail')
})


p1.then(v => {
    console.log(v)
}, err => {
    console.log(err)
})

p2.then(v => {
    console.log(v)
}, err => {
    console.log(err)
})

/**
 * @param {number[]} nums
 * @return {number}
 */
var countAlternatingSubarrays = function(nums) {
    if(!nums || nums.length==0){
        return 0
    }
    let i=1 // pointer
    let k=1 // counter
    let R=1
    for(i=1;i<nums.length;i++){
        if(nums[i]!==nums[i-1]){
            k+=1
            R+=k
        }else{
            k=1
            R+=1
        }
    }
    return R
};

/**
 * @param {number} numBottles
 * @param {number} numExchange
 * @return {number}
 */
var maxBottlesDrunk = function(B, E) {
    let R=0
    let empty=0
    while(true){
        [B,empty,R]=[0,empty+B,R+B]
        if(B==0&&empty<E){
            break
        }
        [B,empty,E]=[1,empty-E,E+1]
    }
    return R
};