const a = '1.2.3.4.5';
a.split('.') // ['1','2','3','4','5']
a.split('.',2)  // ['1','2']

// JavaScript 诞生以来便如此
typeof null === 'object'

// 除了 Function 外的所有构造函数的类型都是 'object'
var str = new String('String');
var str1 = String(12345);
var func = new Function();

typeof str; // 返回'object'
typeof str1; // 返回'string'
typeof func; // 返回'function'

var num = 1;

typeof num + ' hello'; // 'number hellow'
typeof (num + ' hello'); // 'string'

typeof /s/ // 'object' ECMA标准

// 当 typeof 的操作符是未定义 的值会返回 undefined 但是操作符是在typeof后使用 let 或者 const 定义的变量就会报错，因为暂时性死区
typeof undeclar; // undefined;
typeof str; // Uncaught ReferenceError
const str = 'str';

typeof document.all // undefined

// 当前浏览器都是这么实现的但是这并不是ECMA标准

// Number.MAX_SAFE_INTEGER === 9007199254740991
const x = 2n ** 53n;
// 9007199254740992n
const y = x + 1n;
// 9007199254740993n

var num = 1n
var num1 = BigInt(1);

var num = 1;
var num1 =  1n;

num == num1 // true
num === num1 // false

BigInt.asIntN()
// 将一个BigInt值转换成有符号整数
BigInt.asUintN()
// 将一个BIgInt值转换成无符号整数

// 这两个函数都有两个必填参数
width
  可储存整数的位数
bigint
  要储存在指定位数上的整数

  try {
    throw 'error';
  } catch(e) {
    console.log(e); // expected output: "error"
  }

new Error([message],[filename],[lineNumber]);

function isCrushed() {}

if (
  process.env.NODE_ENV !== 'production' &&
  typeof isCrushed.name === 'string' &&
  isCrushed.name !== 'isCrushed'
) {
  warning(
    "You are currently using minified code outside of NODE_ENV === 'production'. " +
      'This means that you are running a slower development build of Redux. ' +
      'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' +
      'or DefinePlugin for webpack (http://stackoverflow.com/questions/30030031) ' +
      'to ensure you have the correct code for your production build.'
  )
}

if (typeof perloadedState === 'function' && typeof enhancer === 'undefined') {
  enhancer = preloadedState;
  preloadedState = undefined
}

if (typeof enhancer !== 'undefined') {
  if (typeof enhancer ! == 'function') {
    throw Error('Expected the enhancer to be a function.')
  }

  return enhancer(createStore)(reducer, preloadedState)
}

if (typeof reducer !=== 'function') {
  throw new Error('Expected the reducer to be a function.')
}

function enhancer (createStroe) {
  // ...
  return function (reducer, preloadedState) {
    // ...
    return {
      dispatch,
      subscribe,
      getState,
      replaceReducer,
    }
  }
}

let currentReducer = reducer;  // 获取reducer
let currentState = preloadedState; // 获取初始store
let currentListeners = [];  // 储存subscribe注册的函数
let nextListeners = currentListeners; // 储存dispatch时subscribe注册的函数，因为如果只使用一个数组存储在dispatch执行中又注册了函数则会调用新注册的函数。
let isDispatching = false;  // 判断是否在dispatch，以截断某些在dispatch时不能进行的操作。

function ensureCanMutateNextListeners() {
  if (nextListeners === currentListeners) {
    nextListeners = currentListeners.slice();
  }
}

function getState() {
  if (isDispatching) {
    throw new Error(
      'You may not call store.getState() while the reducer is executing. ' +
          'The reducer has already received the state as an argument. ' +
          'Pass it down from the top reducer instead of reading it from the store.'
    );
  }
  return currentState;
}

functiong subscribe(listener) {
  if (typeof listener !== 'function') {
    throw new Error('Expected the listener to be a function');
  }

  if (isDispatching) {
    throw new Error(
      'You may not call store.subscribe() while the reducer is executing. ' +
          'If you would like to be notified after the store has been updated, subscribe from a ' +
          'component and invoke store.getState() in the callback to access the latest state. ' +
          'See https://redux.js.org/api-reference/store#subscribe(listener) for more details.'
    );
  }

  let isSubscribed = true;

  ensureCanMutateNextListeners();
  nextListeners.push(listener);

  return functiong unsubscribe() {
    if (!isSubscribed) {
      return;
    }

    if (isDispatching) {
      throw new Error(
        'You may not unsubscribe from a store listener while the reducer is executing. ' +
            'See https://redux.js.org/api-reference/store#subscribe(listener) for more details.'
      );
    }

    isSubscribed = false;

    ensureCanMutateNextListeners();
    const index = nextListeners.indexof(listener);
    nextListeners.splice(index, 1);
  }  
}

function dispatch(action) {
  if (!isPlainObject(action)) {
    throw new Error(
      'Actions must be plain objects. ' +
          'Use custom middleware for async actions.'
    );
  }

  if (typeof action.type === 'undefined') {
    throw new Error(
      'Actions may not have an undefined "type" property. ' +
          'Have you misspelled a constant?'
    )
  }

  if (isDispatching) {
    throw new Error('Reducers may not dispatch actions.');
  }

  try {
    isDispatching = true;
    currentState = currentReducer(currentState, action)
  } finally {
    isDispatching = false;
  }

  const listeners = (currentListeners = nextListeners);
  for (let i = 0; i < listeners.length; i++) {
    const listener = listeners[i];
    listener();
  }

  return action;
}

function replaceReducer(nextReducer) {
  if (typeof nextReducer !== 'function') {
    throw new Error('Expected the nextReducer to be a function.');
  }

  currentReducer = nextReducer;
  dispath({ type: ActionTypes.REPLACE });
}

dispatch({ type: ActionTypes.INIT })

function combineReducers(reducers) {
  const reducerKyes = Object.keys(reducers);
  const finalReducers = {};
  for (let i = 0; i < reducerKeys.length; i++) {
    const key = reducerKeys[i];
    
    if (process.env.NODE_ENV !== 'production') {
      if (typeof reducers[key] === 'undefined') {
        warning(`No reducer provided for key "${key}"`)
      }
    }

    if (typeof reducers[key] === 'function') {
      finalReducers[key] = reducers[key];
    }
  }
  const finalReducerKeys = Object.keys(finalReducers);

  let unexpectedKeyCache;
  if (process.env.NODE_ENV !== 'production') {
    unexpectedKeyCache = {};
  }

  let shapeAssertionError;
  try {
    assertReducerShape(fianlReducers);
  } cache (e) {
    shapeAssertionError = e;
  }

  return function combination(state = {}, action) {
    if (shapeAssertionError) {
      throw shapeAssertionError;
    }

    if (process.env.NODE_ENV !== 'production') {
      const warningMessage = getUnexpectedStateShapeWarningMessage(
        state,
        finalReducers,
        action,
        unexpectedKeyCache
      );

      if (warningMessage) {
        warning(warningMessage);
      }
    }

    let hasChanged = false;
    const nextState = {};
    for (let i = 0; i < finalReducerKeys.length; i++) {
      const key = finalReducerKeys[i];
      const reducer = finalReducers[key];
      const previousStateForKey = state[key];
      const nextStateForKey = reducer(previouStateForKey, action);
      if (typeof nextStateForKey === 'undefined') {
        const errorMessage = getUndefinedStateErrorMessage(key, action);
        throw new Error(errorMessage);
      }
      nextState[key] = nextStateForKey;
      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
    }
    return hasChanged ? nextState : state;
  }
}

function assertReducerShape(reducers) {
  Object.keys(reducers).forEach(key => {
    const reducer = reducers[key];
    const initialState = reducer(undefined, { type: ActionTypes.INIT });

    if (typeof intialState === 'undefined') {
      throw new Error(
         `Reducer "${key}" returned undefined during initialization. ` +
          `If the state passed to the reducer is undefined, you must ` +
          `explicitly return the initial state. The initial state may ` +
          `not be undefined. If you don't want to set a value for this reducer, ` +
          `you can use null instead of undefined.`
      )
    }

    const type = 
      '@@redux/PROBE_UNKNOWN_ACTION_' +
      Math.random()
        .toString(36)
        .substring(7)
        .split('')
        .join('.');
    if (typeof reducer(undefined, { type }) === 'undefined') {
      throw new Error(
        `Reducer "${key}" returned undefined when probed with a random type. ` +
          `Don't try to handle ${
            ActionTypes.INIT
          } or other actions in "redux/*" ` +
          `namespace. They are considered private. Instead, you must return the ` +
          `current state for any unknown actions, unless it is undefined, ` +
          `in which case you must return the initial state, regardless of the ` +
          `action type. The initial state may not be undefined, but can be null.`
      )
    }
  })
}

function getUnexpectedStateShapeWarningMessage(
  inputState,
  reducers,
  action,
  unexpectedKeyCache
) {
  const reducerKeys = Object.keys(reducers)
  const argumentName =
    action && action.type === ActionTypes.INIT
      ? 'preloadedState argument passed to createStore'
      : 'previous state received by the reducer'

  if (reducerKeys.length === 0) {
    return (
      'Store does not have a valid reducer. Make sure the argument passed ' +
      'to combineReducers is an object whose values are reducers.'
    )
  }

  if (!isPlainObject(inputState)) {
    return (
      `The ${argumentName} has unexpected type of "` +
      {}.toString.call(inputState).match(/\s([a-z|A-Z]+)/)[1] +
      `". Expected argument to be an object with the following ` +
      `keys: "${reducerKeys.join('", "')}"`
    )
  }

  const unexpectedKeys = Object.keys(inputState).filter(
    key => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]
  )

  unexpectedKeys.forEach(key => {
    unexpectedKeyCache[key] = true
  })

  if (action && action.type === ActionTypes.REPLACE) return

  if (unexpectedKeys.length > 0) {
    return (
      `Unexpected ${unexpectedKeys.length > 1 ? 'keys' : 'key'} ` +
      `"${unexpectedKeys.join('", "')}" found in ${argumentName}. ` +
      `Expected to find one of the known reducer keys instead: ` +
      `"${reducerKeys.join('", "')}". Unexpected keys will be ignored.`
    )
  }
}

function getUndefinedStateErrorMessage(key, action) {
  const actionType = action && action.type;
  const actionDescription = 
    (actionType && `action "${String(actionType)}"`) || 'an action';
  
  return (
    `Given ${actionDescription}, reducer "${key}" returned undefined. ` +
    `To ignore an action, you must explicitly return the previous state. ` +
    `If you want this reducer to hold no value, you can return null instead of undefined.`
  )
}

function compose(...funcs) {
  if (funcs.length === 0) {
    return arg => arg
  }

  if (funcs.length === 1) {
    return funcs[0];
  }

  return funcs.reduce((a, b) => (...args) => a(b(...args)));
}

if (typeof enhancer !== 'undefined') {
  if (typeof enhancer !== 'function') {
    throw new Error('Expected the enhancer to be a function.')
  }

  return enhancer(createStore)(reducer, preloadedState)
}

// redux-thunk
function createThunkMiddleware(extraArgument) {
  return ({ dispatch, getState }) => next => action => {
    if (typeof action === 'function') {
      return action(dispatch, getState, extraArgunmen);
    }

    return next(action);
  }
}

const thunk = createThunkMiddleware()
thunk.withExtraArgument = createThunkMiddleware;

export default thunk;

const middleware = applyMiddleware(thunk);

// 上面那么多箭头函数写法有点难看懂，我们把它简化了
const fn = next => {
  return action => {
    if (action === 'function') {
      return action(dispatch, getState, extraArgunmen);
    }
    return next(action);
  }
}

const chain = [fn]

dispatch = action => {
  if (action === 'function') {
    return action(dispatch, getState, extraArgunmen);
  }
  return next(action);
}
// 这里的 next 是 store.dispatch 因为chain只有一个函数，如果有多个函数有可能是后一个函数的返回值
// 第三个参数可以进行忽略，因为导出的thunk都没给createThunkMiddleware赋值
// dispatch 和 getState 是在生成 chain 的时候就传入了
// 这里用了两个闭包函数进行缓存变量。。。。

function applyMiddleware(...middlewares) {
  return createStore => (...args) => {
    const store = createStroe(...args);
    let dispatch = () => {
      throw new Error(
        `Dispatching while constructing your middleware is not allowed. ` +
          `Other middleware would not be applied to this dispatch.`
      );
    }

    const middlewareAPI = {
      getState: stroe.getState,
      dispatch: (...args) => dispatch(...args)
    }

    const chain = middlewares.map(middleware => middleware(middlewareAPI));
    dispatch = compose(...chain)(stroe.dispatch);

    return {
      ...stroe,
      dispatch
    }
  }
}

const addTodo = (text) => ({
  type: 'ADD_TODO',
  text
})
// 或者
const todoObj = {
  add: (num) => ({
    type: 'ADD_NUM',
    num
  }),
  minus: (num) => ({
    type: 'MINUS_NUM',
    num
  }),
}

const addTodo = (text) => dispatch({
  type: 'ADD_TODO',
  text
})
// 或者
const todoObj = {
  add: (num) => dispatch({
    type: 'ADD_NUM',
    num
  }),
  minus: (num) => dispatch({
    type: 'MINUS_NUM',
    num
  }) 
}

function bindActionCreator(actionCreator, dispatch) {
  return function() {
    return dispatch(actionCreator.apply(this, arguments));
  }
}

function bindActionCreators(actionCreators, dispatch) {
  if (typeof actionCreators === 'function') {
    return bindActionCreator(actionCreators, dispatch);
  }

  if (typeof actionCreators !== 'object' || actionCreators === null) {
    throw new Error(
      `bindActionCreators expected an object or a function, instead received ${
        actionCreators === null ? 'null' : typeof actionCreators
      }. ` +
        `Did you write "import ActionCreators from" instead of "import * as ActionCreators from"?`
    )
  }

  const keys = Object.keys(actionCreators);
  const boundActionCreators = {};
  for (let i = 0; i < keys.length; i++) {
    const key = keys[i];
    const actionCreator = actionCreators[key];
    if (typeof actionCreator === 'function') {
      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch)
    }
  }

  return boundActionCreators;
}

// 1. 导出所有模块的内容
import * as myModule from '**/**';
// 2. 导出单个接口
import { myExport } from '**/**';
// 3. 导出多个接口
import { foo, bar } from '**/**';
// 4. 导出带有别名的接口
import {
  reallyReallyLongModuleExportName as shortName
}
from '**/**';
// 5. 导入时重命名多个接口
import {
  reallyReallyLongModuleExportName as shortName,
  anotherLongModuleName as short
}
// 6. 仅为副作用而导入一个模块
import '**/**';
// 7. 导入默认值
import default from '**/**';
// 8. 也可以将 default 语法和命名空间导入一起使用，但是这种用法 default 必须首先声明
import default, * as myModule from '**/**';
import default, {foo, bar} from '**/**';
// 9. 动态import
import(**/**).then((module) => {
  // to do
})

// 1. 使用命名导出
var a = **;
var b = **;

export { a, b };
// 使用默认导出
export default function cube(x) { return x * x * x; }
// 模拟重定向
exprot { default } from './other';
export * from './other'

// 1. 添加元素到数组
var arr = [1, 2, 3];
arr.push(4, 5, 6);
console.log(arr);// [1, 2, 3, 4, 5, 6];
// 2. 合并两个数组
var arr1 = [1, 2, 3];
var arr2 = [4, 5, 6];
Array.prototype.push.apply(arr1, arr2);
console.log(arr);// [1, 2, 3, 4, 5, 6];

// call：直接绑定this为第一个参数并且从第二个参数开始都会传入函数然后调用
func.call(thisArg, (arg1), (arg2), ...);
// apply：和call一样只不过传入参数的方式是一个数组
func.apply(thisArg, ([argunmentsArg])
// bind: 调用方式和call一致，只不过bind是返回this绑定的函数且不会直接调用该函数
func.bind(thisArg, (arg1), (arg2), ...);

arr.indexOf(searchElement, (formIndex));

var arr = [undefined];
arr.indexOf(undefined); // 0
var arr1 = new Array(3); // [empty x 3]
arr1.indexOf(undefined); // -1
arr1.inclueds(undefined); // true

好像是因为 new Array 的数组必须要fill

array.splice(start,(deleteCount), item1, item2, ...);

var obj = {a: 1,b: 2};
Object.keys(obj); // ['a', 'b']
Object.values(obj); // [1, 2]
Object.entries(obj); // [['a', 1], ['b', 2]]

  var arr = [1, 2, 3, 4];
  arr.map(x => [x + 1]); // [[2], [3], [4], [5]]
  arr.flatMap(x => [x + 1]); // [2, 3, 4, 5]

var arr1 = [1, 2, 3];
var arr2 = [...arr1, 4, 5]; // [1, 2, 3, 4, 5]

var obj1 = {a:1};
var obj2 = {...obj1, b:2}; //{a:1,b:2}

var fun = function (...args) {console.log(args)}

fun(1, 2, 3, 4, 5); // [1, 2, 3, 4, 5]