It's the comma operator. It evaluates its left-hand operand, throws the result away, evalutes its right-hand operand, and takes that as its result value. It's left-to-right associative, so a, b, c evaluates a, then b, then c, and takes the result of c as its value.
In your example, it's exactly like:
myfunc();
myobj.myvar = someobj.prop;
return myobj;
Some people really prefer to do things on one line, even when there's no objective reason to. There no benefit in the example you gave, and in fact it's confusing because it makes it look like the first two bits relate to the value that will ultimately be returned, which they don't. (I wrote that before you told us it was minified code; obviously, being unclear to humans is only an issue in source code, not minified code.)
Since you've said it's a minifier: The very small possible benefit the minifier might have gotten there is if this is part of a conditional block: It can save one or two characters. If we assume the long form looked like this:
if (someCondition) {
myfunc();
myobj.myvar = someobj.prop;
return myobj;
}
...using the comma operator, the minifier can do this (63 characters):
if(someCondition)return myfunc(),myobj.myvar=someobj.prop,myobj
...rather than this (65 characters):
if(someCondition){myfunc();myobj.myvar=someobj.prop;return myobj}
...without changing the functionality of the code, if what follows is a } or some other appropriate character (or end-of-file) to trigger automatic semicolon insertion at the end. Otherwise, it would need the ; on the first one, but that still saves one character.
