If you look inside ndims.m, you can see

Put simply, it is LENGTH(SIZE(X)).

Now size always returns a vector of length >=2, even for empty arrays (i.e. size([]) is [0 0]). Why that is? Likely a design choice made by TMW long ago.

If you want to measure "actual dimensions" you might want to use:

function nad = nActDims(in)

if numel(in) == 1
  nad = 1;
else
  nad = sum(size(in)>1);
end

or some combination of the functions isscalar, isvector, ismatrix.

That's just the way size is written.

If you wanted a one-liner, you can use subsref to index the one-output form of size:

out = someFunction(arg1,arg2,...
              subsref(size(A),struct('type','()','subs',{{[2,3]}})));

And if you're going to be doing this a lot, add a function somewhere on the Matlab path or make an line one:

sizes = @(A,dims) subsref(size(A),struct('type','()','subs',{{dims}}));
out   = someFunction(arg1,arg2,sizes(A,[2,3]));

You can also create sizes without a direct call to subsref by a little indirection with function handles:

getSizes = @(d,s) d(s);
sizes    = @(A,s) getSizes(size(A),s);

which may be clearer and more maintainable.

Neither. You want to always use numel for this purpose. length only returns the longest dimension (which can get confusing for 2D arrays) and size(data, dimension) requires you to know whether it's a row or column vector. numel will return the number of elements whether it is a row vector, column vector, or multi-dimensional array.

We can easily test the performance of these by writing a quick benchmark. We will take the size with the various methods N times (for this I used 10000).

function size_test

    nRepeats = 10000;

    times1 = zeros(nRepeats, 1);
    times2 = zeros(nRepeats, 1);
    times3 = zeros(nRepeats, 1);

    for k = 1:nRepeats
        data = rand(10000, 1);
        tic
        size(data, 1);
        times1(k) = toc;
        tic
        length(data);
        times2(k) = toc;
        tic
        numel(data);
        times3(k) = toc;
    end

    % Compute the total time required for each method
    fprintf('size:\t%0.8f\n', sum(times1));
    fprintf('length:\t%0.8f\n', sum(times2));
    fprintf('numel:\t%0.8f\n', sum(times3));
end

When run on my machine it yields:

size:   0.00860400
length: 0.00626700
numel:  0.00617300

So in addition to being the most robust, numel is also slightly faster than the other alternatives.

That being said, there are likely many other bottlenecks in your code than determining the number of elements in an array so I would focus on optimizing those.