Existe-t-il un moyen fonctionnel d'initialiser un tableau en JavaScript ES6 ?

Question

J'ai finalement abandonné et j'ai écrit un for pour initialiser un simple tableau d'objets où chaque objet a un compteur incrémenté ( id ) comme un attribut de l'objet. En d'autres termes, je veux juste :

var sampleData = [{id: 1},{id: 2},...];

J'espérais une syntaxe compacte que je pourrais simplement mettre sur ma déclaration de revenus.

let sampleData = [];
for (var p = 0; p < 25; p++){
    sampleData.push({id: p});
}

return {
    data: sampleData,
    isLoading: true
};

Answer 1

Array.from() est un bon moyen de le faire. Vous pouvez passer un {length: somlength} ou un autre objet de type tableau et une fonction qui définit chaque élément. Le premier argument (en l'appelant _ juste pour indiquer qu'il n'est pas utilisé) à cette fonction serait l'élément d'un tableau que nous avons transmis (mais nous n'avons transmis qu'une longueur donc cela ne signifie pas grand chose), le second i est l'index, qui est utilisé pour votre id :

let sampleData = Array.from({length: 10}, (_, id) => ({id}))

console.log(sampleData)

Answer 2

Voici ce que je fais habituellement :

const data = Array(10).fill().map((v, i) => ({id: i + 1}));
console.log({data});

fill garantit qu'il peut être utilisé avec map

Answer 3

Vous pouvez utiliser spread opérateur avec Array et ensuite faire correspondre chaque undefined à l'objet que vous voulez.

var arr = [...Array(10)].map((_,i)=>({id:i}));
console.log(arr)

Answer 4

Vous cherchez un anamorphisme, ou un pliage inversé -

// unfold : ((r, state) -> List r, unit -> List r, state) -> List r
const unfold = (f, init) =>
  f ( (x, next) => [ x, ...unfold (f, next) ]
    , () => [] 
    , init
    )

// sampleData : List { id: Int }
const sampleData =
  unfold
    ( (next, done, i) =>
        i > 25
          ? done ()
          : next ({ id: i }, i + 1)
    , 0
    )

console .log (sampleData)
// [ { id: 0 }, { id : 1 }, ... { id: 25 } ]

Vous pouvez avoir une intuition sur la façon dont unfold fonctionne en le voyant utilisé dans d'autres programmes courants -

// unfold : ((r, state) -> List r, unit -> List r, state) -> List r
const unfold = (f, init) =>
  f ( (x, next) => [ x, ...unfold (f, next) ]
    , () => []
    , init
    )

// fibseq : Int -> List Int
const fibseq = init =>
  unfold
    ( (next, done, [ n, a, b ]) =>
         n === 0
           ? done ()
           : next (a, [ n - 1, b, a + b ])
    , [ init, 0, 1 ]
    )

console .log (fibseq (10))
// [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 ]

La mise en œuvre de unfold n'est qu'une possibilité. Bricolez et mettez-la en œuvre de la manière de votre choix -

// type Maybe a = Nothing | Just a    

// Just : a -> Maybe a
const Just = x =>
  ({ match: ({ Just: f }) => f (x) })

// Nothing : unit -> Maybe a
const Nothing = () =>
  ({ match: ({ Nothing: f }) => f () })

// unfold : (state -> Maybe (a, state), state) -> List a  
const unfold = (f, init) =>
  f (init) .match
    ( { Nothing: () => []
      , Just: ([ x, next ]) => [ x, ...unfold (f, next) ]
      }
    )

// fibseq : Int -> List Int
const fibseq = init =>
  unfold
    ( ([ n, a, b ]) =>
        n === 0
          ? Nothing ()
          : Just ([ a, [ n - 1, b, a + b ] ]) // <-- yikes, read more below
    , [ init, 0, 1 ]
    )

console .log (fibseq (10))
// [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 ]

J'ai triché un peu plus haut en utilisant un [] comme un tuple. Cela a permis de raccourcir le programme, mais il est préférable de modéliser explicitement les choses et de prendre en compte leurs types. Vous avez marqué cette question avec Programmation fonctionnelle Cela vaut donc la peine de faire un effort supplémentaire pour supprimer ce type de traitement implicite de nos programmes. En montrant cela comme une étape séparée, nous isolons une technique qui peut être appliquée non seulement à unfold mais pour tout programme que nous concevons -

// type Maybe a = Nothing | Just a
// type Tuple a b = { first: a, second: b }

// Just : a -> Maybe a
const Just = x =>
  ({ match: ({ Just: f }) => f (x) })

// Nothing : unit -> Maybe a
const Nothing = () =>
  ({ match: ({ Nothing: f }) => f () })

// Tuple : (a, b) -> Tuple a b
const Tuple = (first, second) =>
  ({ first, second })

// unfold : (state -> Maybe Tuple (a, state), state) -> List a  
const unfold = (f, init) =>
  f (init) .match
    ( { Nothing: () => []
      , Just: (t) => [ t.first, ...unfold (f, t.second) ] // <-- Tuple
      }
    )

// fibseq : Int -> List Int
const fibseq = init =>
  unfold
    ( ([ n, a, b ]) =>
        n === 0
          ? Nothing ()
          : Just (Tuple (a, [ n - 1, b, a + b ])) // <-- Tuple
    , [ init, 0, 1 ]
    )

console .log (fibseq (10))
// [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 ]

Answer 5

El .from() L'exemple est génial mais si vous voulez vraiment être créatif, regardez ceci.

const newArray = length => [...`${Math.pow(10, length) - 1}`]
newArray(2)
newArray(10)

Mais très limité

newArray(1000)
["I", "n", "f", "i", "n", "i", "t", "y"]