05AB1E, 5 bytes

Åps.x

Try it online!
or as a Test Suite

Inefficient for big numbers

JavaScript (ES6), 53 bytes

n=>(g=(o,d=N=n+o)=>N%--d?g(o,d):d-1?g(o<0?-o:~o):N)``

Try it online!

Commented

n => (            // n = input

  g = (           // g = recursive function taking:

    o,            //   o = offset

    d =           //   d = current divisor, initialized to N

    N = n + o     //   N = input + offset

  ) =>            //

    N % --d ?     // decrement d; if d is not a divisor of N:

      g(o, d)     //   do recursive calls until it is

    :             // else:

      d - 1 ?     //   if d is not equal to 1 (either N is composite or N = 1):

        g(        //     do a recursive call with the next offset:

          o < 0 ? //       if o is negative:

            -o    //         make it positive (e.g. -1 -> +1)

          :       //       else:

            ~o    //         use -(o + 1) (e.g. +1 -> -2)

        )         //     end of recursive call

      :           //   else (N is prime):

        N         //     stop recursion and return N

)``               // initial call to g with o = [''] (zero-ish)

Octave, 40 bytes

@(n)p([~,k]=min(abs(n-(p=primes(2*n)))))

Try it online!

This uses the fact that there is always a prime between n and 2*n (Bertrand–Chebyshev theorem).

How it works

@(n)p([~,k]=min(abs(n-(p=primes(2*n)))))



@(n)                                      % Define anonymous function with input n

                       p=primes(2*n)      % Vector of primes up to 2*n. Assign to p

                abs(n-(             ))    % Absolute difference between n and each prime

      [~,k]=min(                      )   % Index of first minimum (assign to k; not used)

    p(                                 )  % Apply that index to p

Pyth, 10 bytes

haDQfP_TSy

Try it online here, or verify all the test cases at once here.

haDQfP_TSyQ   Implicit: Q=eval(input())

              Trailing Q inferred

         yQ   2 * Q

        S     Range from 1 to the above

    f         Filter keep the elements of the above, as T, where:

     P_T        Is T prime?

  D           Order the above by...

 a Q          ... absolute difference between each element and Q

                This is a stable sort, so smaller primes will be sorted before larger ones if difference is the same

h             Take the first element of the above, implicit print

Japt, 5 bytes

_j}cU

Try it or run all test cases

_j}cU     :Implicit input of integer U

_         :Function taking an integer as an argument

 j        :  Test if integer is prime

  }       :End function

   cU     :Return the first integer in [U,U-1,U+1,U-2,...] that returns true

Gaia, 3 bytes

ṅD⌡

Try it online!

Rather slow for large inputs, but works given enough memory/time.

I'm not sure why D⌡ implicitly pushes z again, but it makes this a remarkably short answer!

ṅ	| implicit input z: push first z prime numbers, call it P

 D⌡	| take the absolute difference between P and (implicit) z,

	| returning the smallest value in P with the minimum absolute difference

Wolfram Language (Mathematica), 53 bytes

If[PrimeQ[s=#],s,#&@@Nearest[s~NextPrime~{-1, 1},s]]&

Try it online!

Python 2, 96 bytes

l=lambda p:min(filter(lambda p:all(p%n for n in range(2,p)),range(2,p*2)),key=lambda x:abs(x-p))

Try it online!

VDM-SL, 161 bytes

f(i)==(lambda p:set of nat1&let z in set p be st forall m in set p&abs(m-i)>=abs(z-i)in z)({x|x in set{1,...,9**7}&forall y in set{2,...,1003}&y<>x=>x mod y<>0})

A full program to run might look like this - it's worth noting that the bounds of the set of primes used should probably be changed if you actually want to run this, since it will take a long time to run for 1 million:

functions

f:nat1+>nat1

f(i)==(lambda p:set of nat1&let z in set p be st forall m in set p&abs(m-i)>=abs(z-i)in z)({x|x in set{1,...,9**7}&forall y in set{2,...,1003}&y<>x=>x mod y<>0})

Explanation:

f(i)==                                        /* f is a function which takes a nat1 (natural number not including 0)*/

(lambda p:set of nat1                         /* define a lambda which takes a set of nat1*/

&let z in set p be st                         /* which has an element z in the set such that */

forall m in set p                             /* for every element in the set*/

&abs(m-i)                                     /* the difference between the element m and the input*/

>=abs(z-i)                                    /* is greater than or equal to the difference between the element z and the input */

in z)                                         /* and return z from the lambda */

(                                             /* apply this lambda to... */

{                                             /* a set defined by comprehension as.. */

x|                                            /* all elements x such that.. */ 

x in set{1,...,9**7}                          /* x is between 1 and 9^7 */

&forall y in set{2,...,1003}                  /* and for all values between 2 and 1003*/

&y<>x=>x mod y<>0                             /* y is not x implies x is not divisible by y*/

} 

)

APL(NARS), 38 chars, 76 bytes

{⍵≤1:2⋄0π⍵:⍵⋄d←1π⍵⋄(d-⍵)≥⍵-s←¯1π⍵:s⋄d}

0π is the test for prime, ¯1π the prev prime, 1π is the next prime; test:

  f←{⍵≤1:2⋄0π⍵:⍵⋄d←1π⍵⋄(d-⍵)≥⍵-s←¯1π⍵:s⋄d}

  f¨80 100 5 9 532 1

79 101 5 7 523 2 

Jelly, 9 7 bytes

ḤÆRạÞµḢ

Try it online!

Slow for larger input, but works ok for the requested range. Thanks to @EriktheOutgolfer for saving 2 bytes!

Tidy, 43 bytes

{x:(prime↦splice(]x,-1,-∞],[x,∞]))@0}

Try it online!

Explanation

This is a lambda with parameter x. This works by creating the following sequence:

[x - 1, x, x - 2, x + 1, x - 3, x + 2, x - 4, x + 3, ...]

This is splicing together the two sequences ]x, -1, -∞] (left-closed, right-open) and [x, ∞] (both open).

For x = 80, this looks like:

[79, 80, 78, 81, 77, 82, 76, 83, 75, 84, 74, 85, ...]

Then, we use f↦s to select all elements from s satisfying f. In this case, we filter out all composite numbers, leaving only the prime ones. For the same x, this becomes:

[79, 83, 73, 71, 89, 67, 97, 61, 59, 101, 103, 53, ...]

Then, we use (...)@0 to select the first member of this sequence. Since the lower of the two needs to be selected, the sequence which starts with x - 1 is spliced in first.

Note: Only one of x and x - 1 can be prime, so it is okay that the spliced sequence starts with x - 1. Though the sequence could be open on both sides ([x,-1,-∞]), this would needlessly include x twice in the sequence. So, for sake of "efficiency", I chose the left-closed version (also because I like to show off Tidy).

Python 2, 71 bytes

f=lambda n,k=1,p=1:k<n*3and min(k+n-p%k*2*n,f(n,k+1,p*k*k)-n,key=abs)+n

Try it online!

A recursive function that uses the Wilson's Theorem prime generator. The product p tracks $(k-1)!^2$, and p%k is 1 for primes and 0 for non-primes. To make it easy to compare abs(k-n) for different primes k, we store k-n and compare via abs, adding back n to get the result k.

The expression k+n-p%k*2*n is designed to give k-n on primes (where p%k=1), and otherwise a "bad" value of k+n that's always bigger in absolute value and so doesn't affect the minimum, so that non-primes are passed over.

C# (Visual C# Interactive Compiler), 112 bytes

g=>Enumerable.Range(2,2<<20).Where(x=>Enumerable.Range(1,x).Count(y=>x%y<1)<3).OrderBy(x=>Math.Abs(x-g)).First()

Try it online!

Left shifts by 20 in submission but 10 in TIO so that TIO terminates for test cases.

APL (Dyalog Extended), 20 bytes^SBCS

⊢(⊃>/⍤|⍤-⌽⊢)¯4 4⍭3⌈⊢

Try it online!

⊢ the argument

3⌈ max of 3 and that

¯4 4⍭ the previous and next primes`

⊢(…) apply the following infix tacit function to that, with the original argument as left argument:

 ⊢ the primes

 …⌽ cyclically rotate them the following number of steps:

  - the original argument minus the primes

  ⍤ then

  | absolute value of that

  ⍤ then

  >/ Boolean (0/1) whether the left is greater than the right (i.e. 1 if next is closer)

 ⊃ pick the first one (i.e. previous if previous is closer and next if next is closer)

Swift, 186 bytes

func p(a:Int){let b=q(a:a,b:-1),c=q(a:a,b:1);print(a-b<=c-a ? b:c)}

func q(a:Int,b:Int)->Int{var k=max(a,2),c=2;while k>c && c != a/2{if k%c==0{k+=b;c=2}else{c=c==2 ? c+1:c+2}};return k}

Try it online!

Jelly, 14 bytes

ÆpæRÆnạÞƲ2>?2Ḣ

Try it online!

C# (Visual C# Interactive Compiler), 96 bytes

n=>{for(int i=0,j;;)if((j=n+i/2*(i++%2*2-1))>1&&Enumerable.Range(2,j-2).All(d=>j%d>0))return j;}

Try it online!

Zsh, 101 92 91 bytes

-9 by collapsing the body into the head of p's loop, -1 from using i=j instead of i=$1 in main loop.

p(){for ((n=2;n<$1&&$1%n++;)):

(($1==n))&&<<<$1}

j=$1

for ((i=j;;++j&&--i))p $i||p $j&&exit

Try it online!

Try it online!

57 48 bytes to the prime testing function, 43 42 bytes to the main loop (1 byte to the newline between them):

p(){  # prime function: takes one input, outputs via return code

for (( n = 2; n < $1 && $1 % n++; ))   # divisibility check in loop header

    :                 # no-op loop body

(( $1 == n )) &&      # if we looped up to $1:

    <<< $1            #     echo out $1. Otherwise, this will return false

}

For the last condition, we can't use the shorter (($1-n))||, because we need to return false to the main loop if we didn't find a prime. We print in the function to avoid complexity in the main loop.

j=$1                          # set i = j = $1. Doing one in and one out is smallest

for (( i = j; ; ++j && --i )) # loop indefinitely, increment and decrement

    p $i || p $j && exit      # if either $i or $j was a prime, exit

Conditionals are left-associative, which we take advantage of here. We do test the starting number twice to make the decrement logic simpler.

C, 122 bytes

#define r return

p(a,i){if(a<2)r 0;i=1;while(++i<a)if(a%i<1)r 0;r 1;}c(a,b){b=a;while(1){if(p(b))r b;if(p(--a))r a;b++;}}

Use it calling function c() and passing as argument the number, it should return the closest prime.

Python 2, 93 bytes

lambda n:sorted(range(1,3*n),key=lambda x:abs(x-n)if all(x%k for k in range(2,x))else 2*n)[0]

J, 19 15 bytes

(0{]/:|@-)p:@i.

Try it online!