Exprecion regular para palabras y literales

[NSD]

Código Javascript:

var txt = "hola SOY 'un texto ' formado-por \"palabras, comillas & otros caractes \" Y-GUIONES";
 
// Quiero una exprecion regular para poner aca.
var tmp = txt.replace(//g,function(){
 
// que acompañada (o no) de unas lineas de codigo, me permita obtener:
// var matches = ["hola", "SOY", "'un texto '", "formado-por", "\"palabras, comillas & otros caractes \"", "Y-GUIONES"];
 
// Es decir, las palabras que estan separadas por espacios, pero no encerradas entre comillas que pueden ser letras, numeros o giones, nada mas, y lo que esta entre comillas simples o dobles que en su interior pueden contener cualquier cosa, o estar vacias.
});
 

Alguien podria ayudarme?

[zerokilled]

buenas,

muestra lo que haz intentado hasta el momento... no parece tan complicado. aún si te parece complicado, quizas lo más conveniente es que lo hagas por otros métodos involucrando lo más mínimo expresiones regulares.

[NSD]

Hola, lo tengo hecho con una funcion medio horrorosa, lo que hago es enviar toda la cadena de txt como primer parametro a esta funcion:

Código Javascript:

parseArrayParams :  function (str, newP)     
    { 
        (newP != undefined) || (newP = true);
        var prt = str.split('');
        var pos;
        var inText = '';
        var scape = false;
        str = '';
        for(pos=0;pos<prt.length;pos++)
        {
            if(newP && inText == '' && prt[pos] != ' ')
            {
                str += ', ';
                newP  = false;
            }
            if(inText != '' && scape)
            {
                str += prt[pos];
                scape = false;
            }
            else if(inText != '' && prt[pos] == "\\")
            {
                scape=true;
                str += prt[pos];
            }
            else if(prt[pos] == '"' || prt[pos] == '\'')
            {
                if(inText == '')
                    inText = prt[pos];
                else if(inText == prt[pos])
                    inText = '';
                str += prt[pos];
            } else if(prt[pos] != ' ' && inText == '')
            {
                newP = false;
                str += prt[pos];
            } else if(prt[pos] == ' ' && inText == '')
                newP = true;
            else if(inText != '')
                str += prt[pos];                            
        }
        return str;
    }
 

Quiero la exprecion regular para dejar de utilizarla, pero no se me ocurre como puedo hacerlo, si fueran palabras comunes usaria ([\w-]+) pero lo que me complica es que pueden haber palabras con comillas, si a ti te parece que no es complicado, podrias por favor ayudarme a armarla? no sera mas de un renglon

[zerokilled]

para la expresión regular, basicamente una expresión global (flag g) con un OR ( | ). a un lado del OR, buscas palabras que estan separadas por espacios en blanco. al otro lado del OR, buscas comillas simples o dobles seguido por una secuencia de cualquier caracter (metacaracter de punto) y otra comilla igual a la incial. para esto último, tienes que crear una referencia de la comilla coincidida al incio (encerrando entre paréntesis) y usar esa referencia mediante una diagonal invertida y el número correspondiente de acuerdo al número de grupos en la expresión.

ahí te he explicado textualmente lo que tienes que hacer. trata de ensamblarlo.

[NSD]

Muchas gracias, era sencillo despues de todo, aunque sin tu ayuda hubiese tardado mucho mas en lograrlo.

al final me quedo asi:

Código Javascript:

var txt = "hola SOY 'un texto ' formado-por \"palabras, comillas & otros caractes \" Y-GUIONES";
            txt.replace(/(([\w-]+)|("(.*)"+)|('(.*)'+)+)/g, function(a){
                console.log(a);
                
                return '';
            });
 

funciona bien, aunque:

para esto último, tienes que crear una referencia de la comilla coincidida al incio (encerrando entre paréntesis) y usar esa referencia mediante una diagonal invertida

no tengo idea lo que me quisiste decir con esa parte, esta bien como lo hice o tu pensabas en otra forma?

[zerokilled]

parcialmente era lo que te indicaba. aunque si te ha funcionado, pues bien. veamos lo que te explicaba...

una expresión global (flag g) con un OR ( | )
/|/g

a un lado del OR, buscas palabras que estan separadas por espacios en blanco
\b[\w\-]+\b > /|\b[\w\-]+\b/g

al otro lado del OR, buscas comillas simples o dobles seguido por una secuencia de cualquier caracter (metacaracter de punto) y otra comilla igual a la incial
'|".+?'|" > /'|".+?'|"|\b[\w\-]+\b/g

tienes que crear una referencia de la comilla coincidida al incio (encerrando entre paréntesis)
('|").+?'|" > /('|").+?'|"|\b[\w\-]+\b/g

usar esa referencia mediante una diagonal invertida y el número correspondiente de acuerdo al número de grupos en la expresión
('|").+?\1 > /('|").+?\1|\b[\w\-]+\b/g
nótese la sútil diferencia de esta línea con la anterior. en este caso, el orden secuencial de grupos que agrupa las comillas corresponde al primero. por tanto, la referencia es \1.