They are implicitly creating an array of arrays, so you have a few options:

1. A jagged array:

      InventoryItem[][] inventory;
   

2. You could use a multi-dim array. This is no longer an array of arrays, but since all the arrays are the same size in the js above, you are essentially creating a box anyway.

      InventoryItem[,] inventory;
   

3. A list of lists:

      List<List<InventoryItem>> inventory = new List< List<InventoryItem>> ();
   

4. A list of Arrays. This is a possibility, but it would be a bizarre solution for your case.

      List< InventoryItem[] > inventory = new List< InventoryItem[] > ();
   

5. Or an Array of lists, same as number 4, probably not the best choice:

      List<InventoryItem>[] inventory;
   

If you using a list then you will have to make some other adjustments to match the syntax of a list. Just looking at the js, it doesn't look like they resize the array except for the beginning so I would choose any of the first three. Numbers 4 and 5 though would be a little confusing for what you are trying to do so I would probably avoid them since there isn't really any reason in your example to switch types so it would just look strange.

And your other line looks ok since type inference should be able to figure out the type from the right hand side of the assignment operator.

in C# you need to strictly type your array- from what I saw, it's an array of type InventoryItem, so you'd define it like:

InventoryItem [] inventory; // this will create an uninitialized InventoryItem array.

Although for something like this that may have dynamic sizes attributed to it, you may want to consider using a list instead. Also, here's a useful read on arrays/lists/hashtables, etc:

http://robotduck.wordpress.com/2009/11/04/88/

This is a conversion of Der Dude's JavaScript code. I noticed you removed/changed some things in the OnGUI function. But here is his code converted for C#. The only addition I made was the "isInventoryOpen" boolean which you'll have to implement somewhere with a keypress or what have you. (You'll notice the class name is different, InventoryTestCS)

Also...this is a bit clunky. Lists would work best, but As long as you don't edit the size of the inventory in real-time, you should be okay.

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class InventoryTestCS : MonoBehaviour {

    //public static InventoryTestCS statInventory;

    public bool isInventoryOpen = false; //my addition (used to show the inventory)

    public Texture emptyTex;           //This will be drawn when a slot is empty
    public const int inventorySizeX= 8;           //the size of the inventory in x and y dimension
    public const int inventorySizeY= 5;

    //Our inventory array
    InventoryItem[,] inventory;

    int iconWidthHeight= 20;                  //The pixel size (height and width) of an inventory slot
    int spacing= 4;                          //Space between slots (in x and y)

    public Vector2 offSet = new Vector2 (100, 100); //set the position of the inventory


    //Our Representation of an InventoryItem
    public class InventoryItem
    {
        //GameObject this item refers to
        public GameObject worldObject;
        //What the item will look like in the inventory
        public Texture texRepresentation;
    }

    // Create the Inventory
    void Awake()
    {
       inventory = new InventoryItem[inventorySizeX, inventorySizeY];
    }

    void OnGUI()
    {
       if(isInventoryOpen)//if the inventory is open display it
       {
         InventoryItem currentInventoryItem;
         //Go through each row
         for (int i= 0; i < inventorySizeX; i++)
         {
          // and each column
          for( int k = 0; k < inventorySizeY; k ++ )
          {
              currentInventoryItem = inventory[i,k];

              //if there is an item in the i-th row and the k-th column, draw it
              if( inventory[i,k] == null )
              {
                 GUI.DrawTexture( new Rect( offSet.x+k*(iconWidthHeight+spacing), offSet.y+i*(iconWidthHeight+spacing), iconWidthHeight, iconWidthHeight ), emptyTex );
              }
              else
              {
                 GUI.DrawTexture( new Rect( offSet.x+k*(iconWidthHeight+spacing), offSet.y+i*(iconWidthHeight+spacing), iconWidthHeight, iconWidthHeight ), currentInventoryItem.texRepresentation );
              }

              if(currentInventoryItem != null && 
              GUI.Button( new Rect( offSet.x+k*(iconWidthHeight+spacing), offSet.y+i*(iconWidthHeight+spacing), iconWidthHeight, iconWidthHeight ), "", new GUIStyle("label") ))
              {

                 currentInventoryItem.worldObject.transform.position = transform.position;
                 currentInventoryItem.worldObject.transform.rotation = transform.rotation;
                 currentInventoryItem.worldObject.active = true;

                 if(Input.GetMouseButtonUp(0))
                 {     
                   //Equip it
                   currentInventoryItem.worldObject.transform.parent = transform;
                   currentInventoryItem.worldObject.collider.enabled = false;

                 } else if(Input.GetMouseButtonUp(1))
                 {
                   //Drop it
                   inventory[i,k] = null;   
                   currentInventoryItem.worldObject.transform.parent = null;

                 }
              }
          }

         }
       }
    }

    public void AddItem(InventoryItem item)
    {
        //Go through each row
        for (int i= 0; i < inventorySizeX; i++)
        {
            // and each column
            for (int k= 0; k < inventorySizeY; k++)
            {
                //If the position is empty, add the new item and exit the function
                if (inventory[i,k] == null)
                {
                    inventory[i,k] = item;
                    return;
                }
            }
        }
        //If we got this far, the inventory is full, do something appropriate here
    }

    public void AddItem(GameObject worldObject, Texture texRep){
        InventoryItem newItem= new InventoryItem();
        newItem.worldObject = worldObject;
        newItem.texRepresentation = texRep;
        AddItem(newItem);
    }

    void Update()
    {

       if(Input.GetKeyDown("i"))
       {
         isInventoryOpen = !isInventoryOpen;
       }
    }
}

Also, if you are looking for a conversion of the InventoryWorldItem here it is:

using UnityEngine;
using System.Collections;

public class InventoryWorldItem : MonoBehaviour {

    public Texture iconTex;
    public InventoryTestCS inventory;

    void Start()
    {
       //make sure the Player has the inventory script attached otherwise this won't work
       inventory = GameObject.FindWithTag("Player").GetComponent<InventoryTestCS>();
    }

    void OnMouseDown()
    {
       gameObject.active = false;

       InventoryTestCS.InventoryItem item = new InventoryTestCS.InventoryItem();
       item.worldObject = gameObject;
       item.texRepresentation = iconTex;
       inventory.AddItem(item);
    }
}