function squareRoot(n){
    var avg=(a,b)=>(a+b)/2,c=5,b;
    for(let i=0;i<20;i++){
        b=n/c;
        c=avg(b,c);
    }
    return c;
}

This will return the square root by repeatedly finding the average.

var result1 = squareRoot(25) //5
var result2 = squareRoot(100) //10
var result3 = squareRoot(15) //3.872983346207417

JSFiddle: https://jsfiddle.net/L5bytmoz/12/

You can also use bisection - a more general method for solving problems:

var sqrt = function(n) {
    if (n<0) {
        throw "are you kidding?! we are REAL here.";
    }
    if (n === 0) {
        return 0;
    }
    var bisect = function(l,r) {
        var avg = (l+r)/2;
        if (r-l<0.00000001) {
            return (l+r)/2;
        }
        if (avg*avg > n) {
            return bisect(l, avg);
        } else if (avg*avg < n) {
            return bisect(avg, r);
        }
    }
    return bisect(0, n < 1 ? 1 : n);
}

Do not know how your sqrt is implemented (not a javascript coder) so what is faster I can only speculate but there are few fast methods out there using "magic numbers" for IEEE 754 float/double formats and also for integers for example like in Quake3. That works more or less precise with just few ops on defined intervals and are most likely faster then your sqrt but usable only on specific intervals.

Usual sqrt implementations are done by:

1. approximation polynomial

   usually Taylor series, Chebyshev, etc expansions are used and the number of therms is dependent on target accuracy. Not all math functions can be computed like this.

2. iterative approximation

   there are few methods like Newton, Babylonian, etc which usually converge fast enough so no need to use too much therms. My bet is your sqrt use Newtonian approximation.

   There are also binary search based computations

   • Power by squaring for negative exponents

   Binary search requires the same count of iterations then used bits of number result which is usually more then therms used in approximation methods mentioned above. But binary search for sqrt has one huge advantage and that is it can be done without multiplication (which is significant for bignums...)

   • How to get a square root for 32 bit input in one clock cycle only?

   There are also other search approximations like:

   • How approximation search works

3. algebraically using log2,exp2

   you can compute pow from log2,exp2 directly and sqrt(x)=pow(x,0.5) so see

   • How Math.Pow (and so on) actually works

4. LUT

   You can use piecewise interpolation with precomputed look up tables.

5. hybrid methods

   You can combine more methods together like estimate result with low accuracy approximation polynomial and then search around it (just few bits) with binary search ... But this is meaningful only for "big" numbers (in manner of bits)...

6. some math operations and constants can be computed with PCA

   but I see no point to use it in your case...

Also for more info take a look at related QA:

• How is the square root function implemented?

Do not know what are you computing but fastest sqrt is when you do not compute it at all. Many computations and algorithms can be rewritten so they do not need to use sqrt at all or at least not that often (like comparing distances^2 etc...).

For examle if you want to do:

x = Random();
y = sqrt(x);

You can rewrite it to:

y= Random();
x = y*y;

but beware the randomness properties are not the same !!!

This pushes the numbers 0 through 200 into my empty array. What I need my code to do is go through the array and get every number that can be a square root.

No, that's the wrong approach. Don't go through 200 numbers and try to find out which of them is square (has an integer square root). Instead, loop and put only square numbers in the array in the first place! That is much simpler and more efficient.

The nth root of x is the same as x to the power of 1/n. You can simply use Math.pow:

var original = 1000;
var fourthRoot = Math.pow(original, 1/4);
original == Math.pow(fourthRoot, 4); // (ignoring floating-point error)