Entrez en contact avec la programmation fonctionnelle en JavaScript ou Python 3

Qu'est-ce que la programmation fonctionnelle? J'ai essayé d'y toucher car c'était ma première expérience de programmation fonctionnelle avec JavaScript ou Python. J'étudie toujours, je vais donc prendre note de ce que j'ai appris pour le moment.

Le curry est la chose principale aujourd'hui: le curry:

Pour JavaScript

Mouvement préparatoire

main.js

        //Filtrer par filtre

        let talentList = [
            {'name' : "Takeshi Takada" , 'Belong' : null},
            {'name' : "Devise" , 'Belong' : null},
            {'name' : "Midoni" , 'Belong' : "N○"},
            {'name' : "Kokuni" , 'Belong' : null},
            {'name' : "Kassan" , 'Belong' : "Pas de Rashu"},
            {'name' : "jungle" , 'Belong' : "Pas de Rashu"},
        ]

        let getFi = talentList.filter( x => x.Belong === null )
        getFi.forEach( e => console.log(e.name))
        /*
Takeshi Takada
Devise
Kokuni
        */


        //For Each avec le résultat du filtrage

        let ZimushoAruName = []

        talentList
            .filter( x => !x.Belong)
            .forEach( x => ZimushoAruName.push(x.name))
        console.log(ZimushoAruName)

        /*
            (3) ["Midoni", "Kassan", "jungle"]
        */

        //Réduire en quelque sorte populaire

        //Renvoyer le plus grand
        const getMax = (a,b) => a > b ? a : b

        let fruits = [
            { "name" : "pomme" , "price" : 200 },
            { "name" : "Grain de raisin" , "price" : 500 },
            { "name" : "kaki" , "price" : 150 },
            { "name" : "fraise" , "price" : 300 },
            { "name" : "melon" , "price" : 900 },
            { "name" : "banane" , "price" : 100 },
        ]

        let m = fruits.reduce( (a,b) => getMax(a,b.price),0)
        console.log(m)
        // 900

Fonction à rendre difficile cette fois

main.js

const reduce = func => start => datas => datas.reduce( (acum,product) => func(acum)(product.price),0) 

Tout d'abord, soyez doux

main.js

    let ggj = function(c){
        return function(e){
            console.log(c + e)
        }
    }
hogee = ggj("Takeshi Takada") // c
hogee("C'est une rue") // e
//C'est la rue de Takeshi Takada

je ferai de mon mieux

main.js

let a = b => c => d => b * c * d
console.log(a(1)(2)(3))
console.log(a(1)(2)(0))
// 6 
// 0

je ferai de mon mieux

main.js

const products = [
            { "name" : "thé" , "price" : 100 , "sales": 1000 },
            { "name" : "balle de riz" , "price" : 150 , "sales": 1300 },
            { "name" : "Bento" , "price" : 500 , "sales": 300 },
            { "name" : "gâteau" , "price" : 300 , "sales": 200 },
            { "name" : "Poulet frit" , "price" : 200 , "sales": 500 },
        ]
const add = x => y => x + y
const reduce = func => start => datas => datas.reduce( (acum,product) => func(acum)(product.price),0) 
const getSumPrice = reduce(add)(0)(products)
console.log(getSumPrice)
// 1250

Pour Python

Fonction à rendre difficile cette fois

qiita.py

def getData(f):
	return lambda w : lambda v : lambda d : lambda : filter(lambda x : f(x[w])(v),d)

Tout d'abord, soyez doux

qiita.py

product = [
	{'name':'takadakenshi','price':300},
	{'name':'yokoyamamidori','price':100},
	{'name':'babayutaka','price':500},
	{'name':'nodazori','price':10},
	]

#Retour par filtre
def addfilter(datas,price):
	return filter(lambda x: x['price'] >= price,datas)
	
def searchWithPrice(datas):
	return lambda price : lambda : addfilter(datas,price)
	
getsan = searchWithPrice(product)(300)
getyon = searchWithPrice(product)(400)

print(list(getsan()))
print('++++++++++++++')
print(list(getyon()))

'''__Résultat de sortie______________

[{'name': 'takadakenshi', 'price': 300}, {'name': 'babayutaka', 'price': 500}]
++++++++++++++
[{'name': 'babayutaka', 'price': 500}]

_____________'''

je ferai de mon mieux

qiita.py

def eq(a):
	return lambda b : a == b
	
def bigger(a):
	return lambda  b : a >= b
	
def kaiserSearch(func):
	return lambda where : lambda word : lambda product : lambda : filter(lambda x : func(x[where])(word),product)

out2 = kaiserSearch(eq)('name')('babayutaka')(product)
out3 = kaiserSearch(eq)('price')(100)(product)

out4 = kaiserSearch(bigger)('price')(300)(product)

print(list(out2()))
print(list(out3()))
print(''' 
bigger:
''')
print(list(out4()))



'''
Résultat de sortie
[{'name': 'babayutaka', 'price': 500}]
[{'name': 'yokoyamamidori', 'price': 100}]
 
bigger:

[{'name': 'takadakenshi', 'price': 300}, {'name': 'babayutaka', 'price': 500}]


'''

Ce que tu fais est pareil

qiita.py

import requests

url = 'https://jsonplaceholder.typicode.com/users'

json_data = requests.get(url).json()

def eq(a):
	return lambda b : a == b
def getData(f):
	return lambda w : lambda v : lambda d : lambda : filter(lambda x : f(x[w])(v),d)
result = getData(eq)('id')(1)(json_data)

print(list(result()))

ID1 obtenu par json est affiché.