end
```
Comprehension/`map`-ing has an additional advantage: it determines the output’s eltype and shape for you, which is great for some of Julia’s messier parametric types - who wants to type `Array{MArray{Tuple{3}, Float64, 1, 3}}(undef, 10)`?
---
### Author:  [@jonathanBieler](https://discourse.julialang.org/u/jonathanBieler)
#### Post date: [October 16, 2020, 6:18pm UTC](https://discourse.julialang.org/t/best-practice-for-initializing-an-array-prior-to-for-loop/48502/3 "2020-10-16T18:18:31Z")
When using `fill` you’ll go over the whole array in memory fill that with your value, which takes more time. It doesn’t matter for small arrays but for large ones it can be significant :
```julia
julia> @time Vector{Float64}(undef, 100_000_000);
0.000017 seconds (2 allocations: 762.940 MiB)
julia> @time fill(0.0, 100_000_000);
0.229996 seconds (2 allocations: 762.940 MiB)
```
(not sure why the allocation numbers are the same?)
The downside of `Vector` is that your array will be filled with random numbers (whatever is in memory), so if you use these values by mistakes it can lead to hard to find bugs.
Personally I use `Vector` mainly when I have a vector of object more complicated that numbers that I don’t wand to initialize yet (e.g. `Array{Matrix,1}(undef, 20)`)
---
### Author:  [@Sukera](https://discourse.julialang.org/u/Sukera)
#### Post date: [October 16, 2020, 8:08pm UTC](https://discourse.julialang.org/t/best-practice-for-initializing-an-array-prior-to-for-loop/48502/4 "2020-10-16T20:08:18Z")
One disadvantage of using `fill` is that the array is filled _with the same object_, compared to an comprehension which fills it with _distinct objects_:
```julia
julia> mutable struct example f::Int end
julia> a = fill(example(1), 3)
3-element Array{example,1}:
example(1)
example(1)
example(1)
julia> b = [example(1) for _ in 1:3]
3-element Array{example,1}:
example(1)
example(1)
example(1)
julia> a[1] === a[2]
true
julia> b[1] === b[2]
false
julia> a[1].f = 3
3
julia> a
3-element Array{example,1}:
example(3)
example(3)
example(3)
julia> b[1].f = 3
3
julia> b
3-element Array{example,1}:
example(3)
example(1)
example(1)
```
This is because the expression in the comprehension is evaluated for each loop iteration, whereas the argument to `fill` is only evaluated once (before the call).
* * *
As for best practice - each version has its (dis)advantages, so whichever version suits the representation of your problem best. I usually go with comprehensions if the initialization is a long piece of code (which I then put into its own function). When all the function does is initializer an array, I usually either go with the `undef` version if the initialitization is a little bit more complicated and with `zeros` if I was going to start with zeroing the memory anyway.
---
### Author:  [@Sukera](https://discourse.julialang.org/u/Sukera)
#### Post date: [October 16, 2020, 8:12pm UTC](https://discourse.julialang.org/t/best-practice-for-initializing-an-array-prior-to-for-loop/48502/5 "2020-10-16T20:12:51Z")
> [@jonathanBieler](#):
>
> (not sure why the allocation numbers are the same?)
The allocation numbers are the same because in both cases, only the backing memory is allocated. Each Float64 is 8 byte and 800\_000\_000 byte === 762.940 MiB.
---
### Author:  [@aachener](https://discourse.julialang.org/u/aachener)
#### Post date: [October 18, 2020, 1:00am UTC](https://discourse.julialang.org/t/best-practice-for-initializing-an-array-prior-to-for-loop/48502/6 "2020-10-18T01:00:30Z")
Thanks for the explanation.
I tried your code on my machine using julia 1.5.2, the following result is interesting.
Why initiating the array using undef is much slower than using Float64?
```julia
julia> @time Vector(undef,10^8);
0.366178 seconds (2 allocations: 762.940 MiB, 11.75% gc time)
julia> @time Vector{Float64}(undef,10^8);
0.072459 seconds (2 allocations: 762.940 MiB, 97.68% gc time)
julia> @time fill(0.0,10^8);
0.481662 seconds (2 allocations: 762.940 MiB, 14.65% gc time)
```
---
### Author:  [@jling](https://discourse.julialang.org/u/jling)
#### Post date: [October 18, 2020, 1:03am UTC](https://discourse.julialang.org/t/best-practice-for-initializing-an-array-prior-to-for-loop/48502/7 "2020-10-18T01:03:20Z")
> [@aachener](#):
>
> `Vector(undef,10^8)`
this is an `Array{Any,1}`, with elements undefined.
---
### Author:  [@BrunoVasco](https://discourse.julialang.org/u/BrunoVasco)
#### Post date: [April 16, 2021, 4:32pm UTC](https://discourse.julialang.org/t/best-practice-for-initializing-an-array-prior-to-for-loop/48502/8 "2021-04-16T16:32:57Z")
Array comprehensions are generally the most elegant solutions in julia. Its easy to not think about them when we are thinking in for loops and sequential steps and things that we would have done to make it work in Fortran or C… but julia was made to work better with things like that.
Sometimes I forget, but thanks @stillyslalom for helping me remeber it!
`a = [ for i in 1:10]`
Thats a hell of an one-liner!