[Question]
  [
Given two integers as input in an array, draw a rectangle, using the first integer as width and second as height.
Or, if your language supports it, the two integers can be given as separate inputs.
Assume the width and height will never be less than 3, and they will always be given.
Example Outputs:
**[3, 3]**
```
|-|
| |
|-|
```
**[5, 8]**
```
|---|
|   |
|   |
|   |
|   |
|   |
|   |
|---|
```
**[10, 3]**
```
|--------|
|        |
|--------|
```
This is code-golf, so the answer with the lowest amount of bytes wins.
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 14 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
,þ%,ỊḄị“-|| ”Y
```
[Try it online!](http://jelly.tryitonline.net/#code=LMO-JSzhu4rhuIThu4vigJwtfHwg4oCdWQ&input=&args=MTM+OA) or [verify all test cases](http://jelly.tryitonline.net/#code=LMO-JSzhu4rhuIThu4vigJwtfHwg4oCdWQrDpy_igqxq4oCcwrbCtg&input=&args=WzMsIDNdLCBbNSwgOF0sIFsxMCwgM10).
### How it works
```
,þ%,ỊḄị“-|| ”Y  Main link. Left argument: w. Right argument: h
,þ              Pair table; yield a 2D array of all pairs [i, j] such that
                1 ≤ i ≤ w and 1 ≤ j ≤ h.
   ,            Pair; yield [w, h].
  %             Take the remainder of the element-wise division of each [i, j]
                by [w, h]. This replaces the highest coordinates with zeroes.
    Ị           Insignificant; map 0 and 1 to 1, all other coordinates to 0.
     Ḅ          Unbinary; convert each pair from base 2 to integer.
                  [0, 0] -> 0 (area)
                  [0, 1] -> 1 (top or bottom edge)
                  [1, 0] -> 2 (left or right edge)
                  [1, 1] -> 3 (vertex)
       “-|| ”   Yield that string. Indices are 1-based and modular in Jelly, so the
                indices of the characters in this string are 1, 2, 3, and 0.
      ị         At-index; replace the integers by the correspoding characters.
             Y  Join, separating by linefeeds.
```
[Answer]
# Matlab, ~~69~~ ~~65~~ 56 bytes
Thanks @WeeingIfFirst and @LuisMendo for some bytes=)
```
function z=f(a,b);z(b,a)=' ';z([1,b],:)=45;z(:,[1,a])='|'
```
This is really simple in Matlab: First make a matrix of the desired size, then index the first and last row to insert the `-`, and do the same with the first and last column to insert `|`.
For example `f(4,3)` returns
```
|--|
|  |
|--|
```
[Answer]
## JavaScript (ES6), 63 bytes
```
f=
(w,h,g=c=>`|${c[0].repeat(w-2)}|
`)=>g`-`+g` `.repeat(h-2)+g`-`
;
```
```
<div oninput=o.textContent=f(w.value,h.value)><input id=w type=number min=3 value=3><input id=h type=number min=3 value=3><pre id=o>
```
[Answer]
## Haskell, ~~62~~ 55 bytes
```
f[a,b]n=a:(b<$[3..n])++[a]
g i=unlines.f[f"|-"i,f"| "i]
```
Usage example:
```
*Main> putStr $ g 10 3
|--------|
|        |
|--------|
```
The helper function `f` takes a two element list `[a,b]` and a number `n` and returns a list of one `a` followed by `n-2` `b`s followed by one `a`. We can use `f` thrice: to build the top/bottom line: `f "|-" i`, a middle line: `f "| " i` and from those two the whole rectangle: `f [<top>,<middle>] j` (note: `j` doesn't appear as a parameter in `g i` because of partial application). 
Edit: @dianne saved some bytes by combining two `Char` arguments into one `String` of length 2. Thanks a lot! 
[Answer]
# Python 2, ~~61~~ 58 bytes
-3 bytes thanks to @flornquake (remove unnecessary parentheses; use `h` as counter)
```
def f(w,h):exec"print'|'+'- '[1<h<%d]*(w-2)+'|';h-=1;"%h*h
```
Test cases are at **[ideone](http://ideone.com/goqHuN)**
[Answer]
# PHP, 74 Bytes
```
for(;$i<$n=$argv[2];)echo str_pad("|",$argv[1]-1,"- "[$i++&&$n-$i])."|\n";
```
[Answer]
# Vimscript, ~~93~~ ~~83~~ ~~75~~ ~~74~~ ~~73~~ ~~66~~ ~~64~~ 63 bytes
# Code
```
fu A(...)
exe "norm ".a:1."i|\ehv0lr-YpPgvr dd".a:2."p2dd"
endf
```
## Example
```
:call A(3,3)
```
## Explanation
```
fun A(...)    " a function with unspecified params (a:1 and a:2)
exe           " exe(cute) command - to use the parameters we must concatenate :(
norm          " run in (norm) al mode
#i|           " insert # vertical bars
\e            " return (`\<Esc>`) to normal mode
hv0l          " move left, enter visual mode, go to the beginning of the line,  move right (selects inner `|`s)
r-            " (r)eplace the visual selection by `-`s
YpP           " (Y) ank the resulting line, and paste them twice
gv            " re-select the previous visual selection
r<Space>      " replace by spaces
dd            " Cut the line
#p            " Paste # times (all inner rows) 
2dd           " Remove extra lines
```
Note that it is not using `norm!` so it might interfere with vim custom mappings! 
[Answer]
# Jolf, 6 bytes
```
,ajJ'|
```
[Try it here!](http://conorobrien-foxx.github.io/Jolf/#code=LGFqSid8&input=MTAKCjM) My box builtin finally came in handy! :D
```
,ajJ'|
,a       draw a box
  j      with width (input 1)
   J     and height (input 2)
    '    with options
     |    - corner
          - the rest are defaults
```
[Answer]
# [MATL](http://github.com/lmendo/MATL), 19 bytes
```
'|-| '2:"iqWQB]E!+)
```
[Try it online!](http://matl.tryitonline.net/#code=J3wtfCAnMjoiaXFXUUJdRSErKQ&input=NQo4)
### Explanation
The approach is similar to that used in [this other answer](https://codegolf.stackexchange.com/a/93700/36398). The code builds a numerical array of the form
```
3 2 2 2 3
1 0 0 0 1
1 0 0 0 1
1 0 0 0 1
1 0 0 0 1
1 0 0 0 1
1 0 0 0 1
3 2 2 2 3
```
and then its values are used as (1-based, modular) indices into the string `'|-| '` to produce the desired result.
```
'|-| '                % Push this string
      2:"     ]       % Do this twice
         i            % Take input
          q           % Subtract 1
           W          % 2 raised to that
            Q         % Add 1
             B        % Convert to binary
               E      % Multiply by 2
                !     % Transpose
                 +    % Add with broadcast
                  )   % Index (modular, 1-based) into the string
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), ~~23~~ ~~22~~ 20 bytes
Input taken as height, then width.
```
F„ -N_N¹<Q~è²Í×'|.ø,
```
**Explanation**
```
F                          # height number of times do
    N_                     # current row == first row
          ~                # OR
      N¹<Q                 # current row == last row
 „ -       è               # use this to index into " -"
            ²Í×            # repeat this char width-2 times
               '|          # push a pipe
                 .ø        # surround the repeated string with the pipe
                   ,       # print with newline
```
[Try it online!](http://05ab1e.tryitonline.net/#code=RuKAniAtTl9Owrk8UX7DqMKyw43Dlyd8LsO4LA&input=MwoxMA)
Saved 2 bytes thanks to [Adnan](https://codegolf.stackexchange.com/users/34388/adnan)
[Answer]
# C, 73 bytes
```
i;f(w,h){for(i=++w*h;i--;)putchar(i%w?~-i%w%~-~-w?i/w%~-h?32:45:124:10);}
```
[Answer]
# Python 2, 56 bytes
```
w,h=input()
for c in'-%*c'%(h-1,45):print'|'+c*(w-2)+'|'
```
flornquake saved one byte.
[Answer]
## Common Lisp, 104 bytes
Golfed:
```
(defun a(w h)(flet((f(c)(format t"|~v@{~A~:*~}|~%"(- w 2)c)))(f"-")(loop repeat(- h 2)do(f" "))(f"-")))
```
Ungolfed:
```
(defun a (w h)
  (flet ((f (c) (format t "|~v@{~A~:*~}|~%" (- w 2) c)))
    (f "-")
    (loop repeat (- h 2) do
     (f " "))
    (f "-")))
```
[Answer]
# [Turtlèd](https://github.com/Destructible-Watermelon/Turtl-d/), 40 bytes
Interpreter is ~~slightly~~ no longer buggèd
```
?;,u[*'|u]'|?@-[*:l'|l[|,l]d@ ],ur[|'-r]
```
## Explanation
```
?                            - input integer into register
 ;                           - move down by the contents of register
  ,                          - write the char variable, default *
   u                         - move up
    [*   ]                   - while current cell is not *
      '|                     - write |
        u                    - move up
          '|                 - write | again
            ?                - input other integer into register
             @-              - set char variable to -
               [*             ] - while current char is not *
                 :l'|l          - move right by amount in register, move left, write |, move left again
                      [|,l]     - while current cell is not |, write char variable, move left
                           d@   - move down, set char variable to space (this means all but first iteration of loop writes space)
                               ,ur   -write char variable, move up, right
                                  [|   ] -while current char is not |
                                    '-r - write -, move right
```
[Answer]
# Mathematica, ~~67~~ 64 bytes
*Thanks to lastresort and TuukkaX for reminding me that golfers should be sneaky and saving 3 bytes!*
Straightforward implementation. Returns an array of strings.
```
Table[Which[j<2||j==#,"|",i<2||i==#2,"-",0<1," "],{i,#2},{j,#}]&
```
[Answer]
# Python 3, ~~104~~ 95 bytes
( feedback from @mbomb007 : -9 bytes)
```
def d(x,y):return'\n'.join(('|'+('-'*(x-2)if n<1or n==~-y else' '*(x-2))+'|')for n in range(y))
```
(my first code golf, appreciate feedback)
[Answer]
## Batch, 128 bytes
```
@set s=
@for /l %%i in (3,1,%1)do @call set s=-%%s%%
@echo ^|%s%^|
@for /l %%i in (3,1,%2)do @echo ^|%s:-= %^|
@echo ^|%s%^|
```
Takes width and height as command-line parameters.
[Answer]
# Haxe, ~~112~~ 106 bytes
```
function R(w,h){for(l in 0...h){var s="";for(i in 0...w)s+=i<1||i==w-1?'|':l<1||l==h-1?'-':' ';trace(s);}}
```
## Testcases
```
R(5, 8)
|---|
|   |
|   |
|   |
|   |
|   |
|   |
|---|
R(10, 3)
|---------|
|         |
|---------|
```
[Answer]
# Java 135 bytes
```
public String rect(int x, int y){
String o="";
for(int i=-1;++i<y;){
o+="|";
for(int j=2;++j<x)
if(i<1||i==y-1)
o+="-";
else
o+=" ";
o+="|\n";
}
return o;
}
```
Golfed:
```
String r(int x,int y){String o="";for(int i=-1;++i<y;){o+="|";for(int j=2;++j<x;)if(i<1||i==y-1)o+="-";else o+=" ";o+="|\n";}return o;}
```
[Answer]
## PowerShell v3+, 55 bytes
```
param($a,$b)1..$b|%{"|$((' ','-')[$_-in1,$b]*($a-2))|"}
```
Takes input `$a` and `$b`. Loops from `1` to `$b`. Each iteration, we construct a single string. The middle is selected from an array of two single-length strings, then string-multiplied by `$a-2`, while it's surrounded by pipes. The resulting strings are left on the pipeline, and output via implicit `Write-Output` happens on program completion, with default newline separator.
Alternatively, also at 55 bytes
```
param($a,$b)1..$b|%{"|$((''+' -'[$_-in1,$b])*($a-2))|"}
```
This one came about because I was trying to golf the array selection in the middle by using a string instead. However, since `[char]` times `[int]` isn't defined, we lose out on the savings by needing to cast as a string with parens and `''+`.
Both versions require v3 or newer for the `-in` operator.
### Examples
```
PS C:\Tools\Scripts\golfing> .\draw-an-ascii-rectangle.ps1 10 3
|--------|
|        |
|--------|
PS C:\Tools\Scripts\golfing> .\draw-an-ascii-rectangle.ps1 7 6
|-----|
|     |
|     |
|     |
|     |
|-----|
```
[Answer]
# PHP, 82 bytes
```
list(,$w,$h)=$argv;for($p=$h--*$w;$p;)echo$p--%$w?$p%$w?$p/$w%$h?" ":"-":"|
":"|";
```
indexing a static string including the newline
```
list(,$w,$h)=$argv;         // import arguments
for($p=$h--*++$w;$p;)       // loop $p through all positions counting backwards
    // decrease $h and increase $w to avoid parens in ternary conditions
    echo" -|\n"[
        $p--%$w             // not (last+1 column -> 3 -> "\n")
        ?   $p%$w%($w-2)    // not (first or last row -> 2 -> "|")
            ?+!($p/$w%$h)   // 0 -> space for not (first or last row -> 1 -> "-")
            :2
        :3
    ];
```
[Answer]
# Ruby, ~~59~~ ~~54~~ 52 bytes
Oh, that's a lot simpler :)
```
->x,y{y.times{|i|puts"|#{(-~i%y<2??-:' ')*(x-2)}|"}}
```
[Test run at ideone](http://ideone.com/4RlTzz)
[Answer]
# Perl, 48 bytes
Includes +1 for `-n`
Give sizes as 2 lines on STDIN
```
perl -nE 'say"|".$_ x($`-2)."|"for"-",($")x(<>-1-/$/),"-"'
3
8
^D
```
Just the code:
```
say"|".$_ x($`-2)."|"for"-",($")x(<>-1-/$/),"-"
```
[Answer]
# Lua, 120 93 bytes
Saved quite a few bytes by removing stupid over complexities.
```
function(w,h)function g(s)return'|'..s:rep(w-2)..'|\n'end b=g'-'print(b..g' ':rep(h-2)..b)end
```
Ungolfed:
```
function(w,h)                           -- Define Anonymous Function
    function g(s)                       -- Define 'Row Creation' function. We use this twice, so it's less bytes to function it.
        return'|'..s:rep(w-2)..'|\n'    -- Sides, Surrounding the chosen filler character (' ' or '-'), followed by a newline
    end
    b=g'-'                              -- Assign the top and bottom rows to the g of '-', which gives '|---------|', or similar.
    print(b..g' ':rep(h-2)..b)          -- top, g of ' ', repeated height - 2 times, bottom. Print.
end
```
[Try it on Repl.it](https://repl.it/Dc0e/8)
[Answer]
# Python 2, 67 bytes
```
def f(a,b):c="|"+"-"*(a-2)+"|\n";print c+c.replace("-"," ")*(b-2)+c
```
**Examples**
```
f(3,3)
|-|
| |
|-|
f(5,8)
|---|
|   |
|   |
|   |
|   |
|   |
|   |
|---|
f(10,3)
|--------|
|        |
|--------|
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~21~~ 17 bytes
```
Z"45ILJhY('|'5MZ(
```
This is a slightly different approach than the one of the [MATL-God](https://codegolf.stackexchange.com/a/93725/24877).
```
Z"                   Make a matrix of spaces of the given size
  45ILJhY(           Fill first and last row with '-' (code 45)
          '|'5MZ(    Fill first and last column with '|' (using the automatic clipboard entry 5M to get ILJh back)
```
Thanks @LuisMendo for all the help!
[Try it Online!](http://matl.tryitonline.net/#code=WiI0NUlMSmhZKCd8JzVNWig&input=WzUgOF0)
[Answer]
# PHP 4.1, 76 bytes
```
<?$R=str_repeat;echo$l="|{$R('-',$w=$W-2)}|
",$R("|{$R(' ',$w)}|
",$H-2),$l;
```
This assumes you have the default `php.ini` settings for this version, including [`short_open_tag`](http://php.net/manual/en/ini.core.php#ini.short-open-tag) and [`register_globals`](http://php.net/manual/en/ini.core.php#ini.register-globals) enabled.
This requires access through a web server (e.g.: Apache), passing the values over session/cookie/POST/GET variables.  
The key `W` controls the width and the key `H` controls the height.  
For example: `http://localhost/file.php?W=3&H=5`
[Answer]
# Python 3, 74 chars
```
p="|"
def r(w,h):m=w-2;b=p+"-"*m+p;return b+"\n"+(p+m*" "+p+"\n")*(h-2)+b
```
[Answer]
# Swift(2.2) 190 bytes
```
let v = {(c:String,n:Int) -> String in var s = "";for _ in 1...n {s += c};return s;};_ = {var s = "|"+v("-",$0-2)+"|\n" + v("|"+v(" ",$0-2)+"|\n",$1-2) + "|"+v("-",$0-2)+"|";print(s);}(10,5)
```
I think Swift 3 could golf this a lot more but I don't feel like downloading Swift 3.
[Answer]
## F#, 131 bytes
```
let d x y=
 let q = String.replicate (x-2)
 [for r in [1..y] do printfn "%s%s%s" "|" (if r=y||r=1 then(q "-")else(q " ")) "|"]
```
]