JavaScript：了解一下函数式编程

 //定义一个箭头函数
 var print = (message) => console.log(message)

 //将函数作为数值使用
 const array = ["XYQ",print]
 console.log(array) //["XYQ", function] (2)

 //将函数作为参数使用
 //定义一个函数lg，它接收一个参数logger函数，lg的函数体内部会执行这个参数logger函数
 //由于传入的print函数可以接收一个参数，所以logger函数在执行时，默认传入了一个字符串
 const lg = logger => logger("I Am XYQ")
 lg(print) //I Am XYQ

 //将函数作为返回值使用
 //定一个函数fcVale，它接收一个logger函数，同时它的返回值为新的函数，新的函数可以传入
 //一个变量进行打印。最终，用函数fcVale创建一个函数fc，并给fc函数传入字符串进行调用
 // var fcVale = function (logger) {
 //     return (message) => logger(message.toUpperCase())
 // }
 const fcVale = logger => message => logger(message.toUpperCase()) //高阶函数, 函数既可以接收函数参数，也可以作为其他函数返回值
 const fc = fcVale(print)
 fc("i am xyq") //I AM XYQ

 //定义一个字符串变量
 var userString = "My Name is XYQ"

 //命令式：遍历字符串，将字符串的空格全部用下划线替换 【开发者必须看完这个代码快才能知道函数的作用是替换功能】
 var temp = ""
 for (var i=0; i<userString.length; i++){
    if (userString[i] === " "){
         temp += "_"
    } else {
         temp += userString[i]
    }
 }
 console.log(temp) //My_Name_is_XYQ

 //声明式：使用正则表达式，将字符串的空格全部用下划线替换 【开发者看到replace就基本知道函数的用途就是替换功能】
 const user_string = userString.replace(/ /g,"_")
 console.log(user_string) //My_Name_is_XYQ

<script type="text/javascript">
  
   //定义一个person对象
   var person = {
       name: "XYQ",
       age: 25,
       sex: "male"
   }

   //方法一：通过Obejct.assign方法拷贝机制，创建一个空白对象，并将当前对象拷贝到空白对象上，接着重写对象值
   var copyPerson = function (person, name) {
       return Object.assign({}, person, {name:name}) // {} 为一个空白对象, person拷贝到{}上，重写name值
   }
   var newPerson = copyPerson(person,"YPX")
   console.log(newPerson.name) //YPX
   console.log(person.name)    //XYQ，可以看到原对象没有发生改变

   //方法二：通过扩展运算符特性对对象进行拷贝
   const copyPerson2 = (person, name) => ({
       ...person,
       name
   })
   var newPerson2 = copyPerson(person,"YPX")
   console.log(newPerson2.name)  //YPX
   console.log(person.name)      //XYQ，可以看到原对象没有发生改变

   //---------------------------------------------------------------------------------//
        
   //定义一个数组对象
   var persons = [
       {name:"XYQ"},
       {name:"YPX"}
   ]

   //方法一：使用数组的Array.concat方式将数组串联起来，生成一个新的对象并添加原生数组的副本上，不可以用Array.push这个可变函数
   const addPerson = (name, persons) => persons.concat({name})
   var newPersons = addPerson("HXF", persons)
   console.log(newPersons) //[{name: "XYQ"}, {name: "YPX"}, {name: "HXF"}] (3)
   console.log(persons)    //[{name: "XYQ"}, {name: "YPX"}] (2)，可以看到原数组没有发生改变

   //方式二：使用扩展运算法特性对数组进行拷贝
   const addPerson2 = (name, persons) => [...persons, {name}]
   var newPersons2 = addPerson2("HXF", persons)
   console.log(newPersons2) //[{name: "XYQ"}, {name: "YPX"}, {name: "HXF"}] (3)
   console.log(persons)     //[{name: "XYQ"}, {name: "YPX"}] (2)，可以看到原数组没有发生改变

</script>

纯函数特点：
1、函数应该至少接收一个参数；
2、函数应该返回一个值或者其他函数；
3、函数不应该修改或者影响任何传给它的参数

<script type="text/javascript">

  //定义一个person对象
  var person = {
      name: "XYQ",
      age: 25,
      sex: "male"
  }

  //创建一个纯函数，返回值是根据参数preson生成的一个新的person，它没有改变参数person，更改的返回的新的person。
  const updatePerson = person => ({
      ...person,
      name:"YPX",
      sex:"feMale"
  })

  //打印
  var newPerson = updatePerson(person)
  console.log(newPerson) // {name: "YPX", age: 25, sex: "feMale"}
  console.log(person)    // {name: "XYQ", age: 25, sex: "male"}, 原对象person没有发生改变

</script>

 //定义一个city数组
 const cities = ["BeiJing","ChongQing","ChongDu"]

 //使用系统函数Array.join()将数组用分隔符连接成字符串
 var cityString = cities.join(",")
 console.log(cityString) // BeiJing,ChongQing,ChongDu
 console.log(cities)     // ["BeiJing", "ChongQing", "ChongDu"] (5)

 //使用系统函数Array.filter()进行谓词过滤，这个谓词始终是一个返回布尔值的函数
 //会访问数组每一个元素，匹配C开头的城市，如果返回true，则将其添加到新的数组中
 const newCities = cities.filter(city => city[0] === "C")
 console.log(newCities) // ["ChongQing", "ChongDu"] (2)
 console.log(cities)    // ["BeiJing", "ChongQing", "ChongDu"] (5)

 //仍然使用系统函数Array.filter()，代替Array.pop()和Array.splice()函数删除元素。因为后面的两个方法是可变的。
 const deleteCity = (deletedCity, cities) => cities.filter(city => city !==    deletedCity)
 const newCities2 = deleteCity("BeiJing", cities)
 console.log(newCities2) // [ "ChongQing", "ChongDu"] (4)
 console.log(cities)     // ["BeiJing","ChongQing", "ChongDu"] (5)

 //使用系统函数Array.map()，参数也是一个函数，在函数在访问数组中每一个元素时会执行
 const  newCities3 = cities.map(city => `${city} China`)
 console.log(newCities3) // ["BeiJing China","ChongQing China", "ChongDu China"] (5)
 console.log(cities) //["BeiJing", "ChongQing", "ChongDu"] (5)

 // 仍然使用系统函数Array.map()，她还可以构造任意对象、数值、数组、函数等
 // 1、将数组转对象
 let objectCities = cities.map(city => ({cityName : city}))
 console.log(objectCities) // [{cityName: "BeiJing"}, {cityName: "ChongQing"}, {cityName: "ChongDu"}] (3)
 console.log(cities) // ["BeiJing", "ChongQing", "ChongDu"] (3)

 // 2、修改对象元素
 const updateCityName = (originCityName, cityName, cities) =>
            (cities.map(city => (city.cityName === originCityName) ? ({...city, cityName}) : city))
 const newObjectCities = updateCityName("BeiJing","TianJin",objectCities)
 console.log(objectCities) //[{cityName: "BeiJing"}, {cityName: "ChongQing"}, {cityName: "ChongDu"}] (3)
 console.log(newObjectCities) //[{cityName: "TianJin"}, {cityName: "ChongQing"}, {cityName: "ChongDu"}] (3)

 // 3、将对象转数组(配合Object.key函数使用)
 //定义一个city对象
 const cityObject = {"BeiJing":"China","NewYork":"USA"}
 const cityObjects = Object.keys(cityObject).map(key =>
     ({cityName: key, country: cityObject[key]})
 )
 console.log(cityObject) //{BeiJing: "China", NewYork: "USA"}
 console.log(cityObjects)//[{cityName: "BeiJing", country: "China"}, {cityName:  "NewYork", country: "USA"}](2)

 // 系统函数Array.reduce()和rArray.reduceRight()可以用来将数组转成任意值，比如数字、字符串、布尔值、对象甚至函数
 // Array.reduce()函数, 从数组头部开始处理元素 ; Array.reduceRight()函数，从数组尾部 开始处理元素
 // 求最值
 const nums = [10,5,30,24,78,60,100]
 const max = nums.reduce((max, num) => (num > max) ? num : max)
 const min = nums.reduce((min, num) => (num < min) ? num : min)
 console.log(max) // 100
 console.log(min) // 5

 // 去重，items为新的空数组
 const names = ["XYQ","YPX","XXF","XYQ","XYQ"]
 const deletedNames = names.reduce((items, name)=> items.indexOf(name) !== -1 ? items : [...items,name], [])
 console.log(names) //["XYQ", "YPX", "XXF", "XYQ", "XYQ"] (5)
 console.log(deletedNames) //["XYQ", "YPX", "XXF"] (3)

 //定义高阶函数，把函数当做参数
 const printer = () => console.log("---printer---")
 const logger  = () => console.log("---logger---")
 const show = (selectPrint, printer, logger) => (selectPrint) ? printer() : logger()

 //调用高阶函数
 show(true,printer,logger)  //---printer---
 show(false,printer,logger) //---logger---
        
 //定义高阶函数，把函数当做返回值
 const log = (message) =>( () => console.log(message) )
 const logFunction = log("I Am XYQ")

 //调用高阶函数
 logFunction() //I Am XYQ

 //定义一个倒序遍历的函数
 const countDown = (number, log) => {
      log(number)
      return (number > 0) ? countDown(number-1, log) : number
 }

 //调用递归函数
 const log = (number) => console.log(number)
 countDown(5,log)// 5 4 3 2 1 0

 //使用系统函数replace实现链式调用
 const formmater = "hh:mm:ss tt"
 const currentTime = formmater.replace("hh", "22").replace("mm","07").replace("ss","00").replace("tt","PM")
 console.log(currentTime) //22:07:00 PM