---
# System prepended metadata

title: Qu'est ce qu'une fonction

---

# Qu'est ce qu'une fonction 

Une fonction est un ensemble d'action à realiser dans un but precis et eviter la réecriture des actions dans plusieurs endroit . 

Une fonction doit etre :

1) Déclarer : on decrit ce qu'elle fait , les actions qu'elle va faire (à faire une seule fois)
2) Executer : on lance, on l'utilise à un ou plusieurs endroit (à faire plusieurs fois quand on veut utiliser la fonction)

Une fonction peut avoir des entrés ou input nécessaire à son fonctionnement = des arguments
Une fonction peut avoir des sorties ou output qui decrit ses resultats 

# Exemple en Javascript

### Déclarer une fonction


```
function helloworld() {
	console.log('Hello world!') // Le output
}
```

```
function salut(nom) { // nom = argument ou input
	return 'Bonjour ' + nom; // autre type de output qu'on peut stocker dans une variable lors de l'utilsation ou execution de la fonction
}
```

une fonction peut avoir 0 à n arguments séparé par des virgules

```
function addition(valeur, valeur2) {
    return valeur + valeur2
}
```


### Utilisation

```
helloworld() // sans le terme function
```

> `Hello world`

```
salut('safidy') // le input 'safidy' est stocké dans la variable nom lors de la declaration
salut('rakoto')
salut('rabe')
```

> `Bonjour safidy`
> `Bonjour rakoto`
> `Bonjour rabe`

On peut utiliser autant de fois la fonction `salut` sans repeter ses actions. Une seule declaration et plusieurs utilisations.

Exemple, je veux faire plusieurs additions avec la fonction déclarée ci-dessus.

```
addition(1, 2) // 1 + 2
```
> 3

```
addition(4, 3)
```

> 7


```
sum([1, 4, 7]) 
```

> 12



### Exemple

```
var somme = arraySum([5, 20, 50])
console.log(somme)
```

> 75


## Correction

#### 1


```
function rangeGenerator(min, max) {
    const tab = []
    for (i = min; i <= max; i++) {
        tab.push(i)
    }   

    return tab
}
```

#### 2

```
function arraySum(tab) {
    let sum = 0
    tab.forEach(item => {
        sum += item
    })
    
    return sum
}
```


#### 3

```
function dataConstructor(collection) {
  const prepared = []
  
  collection.forEach(item => {
      prepared.push({
          id: item.id,
          fullname: item.firstname + ' ' + item.lastname
      })
  })
  
  return prepared
}
```

#### 4

```
function arrayFlatten(tab) {
  const data = []

  const flat = tab.flat()

  flat.forEach(item => {
    if (!data.includes(item)) {
      data.push(item)
    }
  })

  return data
}
```

#### 5

```
function arrayAverage(tab) {
  let sum = 0
  tab.forEach(item => {
      sum += item
  })
  
  return sum/tab.length  
}
```

#### 6


#### 7


```
function arrayToString(tableau) {
  tableau = tableau.flat()
  
  let results = ''
  tableau.forEach (item => {
    if (typeof item === 'string') {
      results += ' ' + item
    }
  })

  return results
} 

```

#### 8

```
const tab = [3, 4, 2, 1, 7]

function arrayMax(collection) {
  const item = {
    value: 0,
    position: 0
  }
  collection.forEach((element, index) => {
    if (element >= item.value) {
      item.value = element
      item.position = index
    }
  })

  return item
}

console.log(arrayMax(tab))
```

#### 9

```
const tab = [3, 4, 2, 1, 7]

function arrayMin(collection) {
  const item = {
    value: 0,
    position: 0
  }
  collection.forEach((element, index) => {
    if (element < item.value) {
      item.value = element
      item.position = index
    }
  })

  return item
}

console.log(arrayMin(tab))
\\``