The Non-Zero Digital Product Challenge Originally the Multiplicative digital root
Challenge
Basically do what the title says
Method
Given a positive integer  1 &lt;= N &lt;= 100000000 through one of our standard input methods, multiply every digit together, ignoring zeroes.
Ex: Take a number, say 361218402:

3 * 6 = 18
18 * 1 = 18
18 * 2 = 36
36 * 1 = 36
36 * 8 = 288
288 * 4 = 1152
1152 * 1 (ignore zeroes or turn them into ones) = 1152
1152 * 2 = 2304

The output for 361218402 is 2304
Test Cases

1 => 1
every other digit > 0 => itself
10 => 1
20 => 2
100 => 1
999 => 729
21333 => 54
17801 => 56
4969279 => 244944
100000000 => 1

Standard Loopholes are disallowed, and this is code-golf, so shortest byte count wins!
Congrats to Jo King who got the bounty with his 70 byte brain-flak answer!
Haskell, 27 bytes



foldr((*).max 1.read.pure)1


Try it online!

Ungolfed with UniHaskell and -XUnicodeSyntax

import UniHaskell

f ∷ String → Int
f = product ∘ map (max 1 ∘ read ∘ pure)




Explanation

I'll start with what I initially had:

product.map(max 1.read.pure)


This is a point-free expression that evaluates to a function taking a string (or a list of characters) s ("301") as an argument. It maps max 1.read.pure over s, essentially taking each character i, injecting it into a list (which makes it a string) (["3", "0", "1"]), then reading it, which evaluates the string ([3, 0, 1]) and finally taking the greater of i and 1 ([3, 1, 1]). Then it takes the product of the resulting list of integers (3).

I then golfed it by a byte with:

foldr((*).max 1.read.pure)1


This works because product is equivalent to foldr (*) 1. Instead of mapping and folding, I combined the two by folding with (*).max 1.read.pure which takes each non-zero digit and multiplies it with the accumulator.