javascript - una - pasar parametros por url html
Agregar un parámetro a la URL con JavaScript (26)
¿Alguna vez vemos ? En la URL final, encontré algunas soluciones que generan resultados como file.php?&foo=bar . ¡se me ocurrió que mi propia solución funcionaba perfectamente como yo quería!
location.origin + location.pathname + location.search + (location.search=='''' ? ''?'' : ''&'') + ''lang=ar''
Nota: location.origin no funciona en IE, aquí está su solución .
En una aplicación web que hace uso de llamadas AJAX, debo enviar una solicitud pero agregar un parámetro al final de la URL, por ejemplo:
URL original:
URL resultante:
http://server/myapp.php?id=10 & enabled = true
Buscando una función de JavaScript que analice la URL mirando cada parámetro, luego agrega el nuevo parámetro o actualiza el valor si ya existe uno.
Aquí hay una versión muy simplificada, haciendo intercambios de legibilidad y menos líneas de código en lugar de rendimiento micro optimizado (y estamos hablando de una diferencia de unos pocos milisegundos, de forma realista ... debido a la naturaleza de esto (operando en la ubicación del documento actual) ), lo más probable es que se ejecute una vez en una página).
/**
* Add a URL parameter (or changing it if it already exists)
* @param {search} string this is typically document.location.search
* @param {key} string the key to set
* @param {val} string value
*/
var addUrlParam = function(search, key, val){
var newParam = key + ''='' + val,
params = ''?'' + newParam;
// If the "search" string exists, then build params from it
if (search) {
// Try to replace an existance instance
params = search.replace(new RegExp(''([?&])'' + key + ''[^&]*''), ''$1'' + newParam);
// If nothing was replaced, then add the new param to the end
if (params === search) {
params += ''&'' + newParam;
}
}
return params;
};
Entonces lo usarías así:
document.location.pathname + addUrlParam(document.location.search, ''foo'', ''bar'');
Con los nuevos logros en JS, aquí es cómo se puede agregar el parámetro de consulta a la URL:
var protocol = window.location.protocol,
host = ''//'' + window.location.host,
path = window.location.pathname,
query = window.location.search;
var newUrl = protocol + host + path + query + (query ? ''&'' : ''?'') + ''param=1'';
window.history.pushState({path:newUrl}, '''' , newUrl);
También vea esta posibilidad Moziila URLSearchParams.append ()
Consulte https://github.com/derek-watson/jsUri
Uri y manipulación de cadena de consulta en javascript.
Este proyecto incorpora la excelente biblioteca de expresión regular parseUri de Steven Levithan. Puede analizar con seguridad URL de todas las formas y tamaños, aunque no sean válidas u horribles.
Esta es una forma simple de agregar un parámetro de consulta:
const query = new URLSearchParams(window.location.search);
query.append("enabled", "true");
Y eso es developer.mozilla.org/en-US/docs/Web/API/URLSearchParams .
Tenga en cuenta las especificaciones de soporte .
Esta es una solución muy simple. No controla la existencia del parámetro, y no cambia el valor existente. Agrega su parámetro al final, para que pueda obtener el último valor en su código de back-end.
function addParameterToURL(param){
_url = location.href;
_url += (_url.split(''?'')[1] ? ''&'':''?'') + param;
return _url;
}
Este fue mi propio intento, pero usaré la respuesta de annakata ya que parece mucho más limpio:
function AddUrlParameter(sourceUrl, parameterName, parameterValue, replaceDuplicates)
{
if ((sourceUrl == null) || (sourceUrl.length == 0)) sourceUrl = document.location.href;
var urlParts = sourceUrl.split("?");
var newQueryString = "";
if (urlParts.length > 1)
{
var parameters = urlParts[1].split("&");
for (var i=0; (i < parameters.length); i++)
{
var parameterParts = parameters[i].split("=");
if (!(replaceDuplicates && parameterParts[0] == parameterName))
{
if (newQueryString == "")
newQueryString = "?";
else
newQueryString += "&";
newQueryString += parameterParts[0] + "=" + parameterParts[1];
}
}
}
if (newQueryString == "")
newQueryString = "?";
else
newQueryString += "&";
newQueryString += parameterName + "=" + parameterValue;
return urlParts[0] + newQueryString;
}
Además, encontré este plugin jQuery de otra publicación en , y si necesita más flexibilidad puede usarlo: http://plugins.jquery.com/project/query-object
Creo que el código sería (no se ha probado):
return $.query.parse(sourceUrl).set(parameterName, parameterValue).toString();
Esto es lo que hago. Usando mi función editParams (), puede agregar, eliminar o cambiar cualquier parámetro, luego usar la función incorporada en replaceState () para actualizar la URL:
window.history.replaceState(''object or string'', ''Title'', ''page.html'' + editParams(''enable'', ''true''));
// background functions below:
// add/change/remove URL parameter
// use a value of false to remove parameter
// returns a url-style string
function editParams (key, value) {
key = encodeURI(key);
var params = getSearchParameters();
if (Object.keys(params).length === 0) {
if (value !== false)
return ''?'' + key + ''='' + encodeURI(value);
else
return '''';
}
if (value !== false)
params[key] = encodeURI(value);
else
delete params[key];
if (Object.keys(params).length === 0)
return '''';
return ''?'' + $.map(params, function (value, key) {
return key + ''='' + value;
}).join(''&'');
}
// Get object/associative array of URL parameters
function getSearchParameters () {
var prmstr = window.location.search.substr(1);
return prmstr !== null && prmstr !== "" ? transformToAssocArray(prmstr) : {};
}
// convert parameters from url-style string to associative array
function transformToAssocArray (prmstr) {
var params = {},
prmarr = prmstr.split("&");
for (var i = 0; i < prmarr.length; i++) {
var tmparr = prmarr[i].split("=");
params[tmparr[0]] = tmparr[1];
}
return params;
}
Esto es lo que uso cuando se trata de adiciones de parámetros básicos de URL o actualizaciones en el lado del servidor como Node.js.
CoffeScript:
###
@method addUrlParam Adds parameter to a given url. If the parameter already exists in the url is being replaced.
@param {string} url
@param {string} key Parameter''s key
@param {string} value Parameter''s value
@returns {string} new url containing the parameter
###
addUrlParam = (url, key, value) ->
newParam = key+"="+value
result = url.replace(new RegExp(''(&|//?)'' + key + ''=[^/&|#]*''), ''$1'' + newParam)
if result is url
result = if url.indexOf(''?'') != -1 then url.split(''?'')[0] + ''?'' + newParam + ''&'' + url.split(''?'')[1]
else if url.indexOf(''#'') != -1 then url.split(''#'')[0] + ''?'' + newParam + ''#'' + url.split(''#'')[1]
else url + ''?'' + newParam
return result
JavaScript:
function addUrlParam(url, key, value) {
var newParam = key+"="+value;
var result = url.replace(new RegExp("(&|//?)"+key+"=[^/&|#]*"), ''$1'' + newParam);
if (result === url) {
result = (url.indexOf("?") != -1 ? url.split("?")[0]+"?"+newParam+"&"+url.split("?")[1]
: (url.indexOf("#") != -1 ? url.split("#")[0]+"?"+newParam+"#"+ url.split("#")[1]
: url+''?''+newParam));
}
return result;
}
var url = "http://www.example.com?foo=bar&ciao=3&doom=5#hashme";
result1.innerHTML = addUrlParam(url, "ciao", "1");
<p id="result1"></p>
Esto funcionará en todos los navegadores modernos.
function insertParam(key,value) {
if (history.pushState) {
var newurl = window.location.protocol + "//" + window.location.host + window.location.pathname + ''?'' +key+''=''+value;
window.history.pushState({path:newurl},'''',newurl);
}
}
Gracias a todos por su contribución. Usé el código annakata y lo modifiqué para incluir también el caso en el que no hay una cadena de consulta en la url. Espero que esto ayude.
function insertParam(key, value) {
key = escape(key); value = escape(value);
var kvp = document.location.search.substr(1).split(''&'');
if (kvp == '''') {
document.location.search = ''?'' + key + ''='' + value;
}
else {
var i = kvp.length; var x; while (i--) {
x = kvp[i].split(''='');
if (x[0] == key) {
x[1] = value;
kvp[i] = x.join(''='');
break;
}
}
if (i < 0) { kvp[kvp.length] = [key, value].join(''=''); }
//this will reload the page, it''s likely better to store this until finished
document.location.search = kvp.join(''&'');
}
}
La siguiente función te ayudará a agregar, actualizar y eliminar parámetros ao desde la URL
//Ejemplo 1
var myURL = ''/search'';
myURL = updateUrl(myURL,''location'',''california'');
console.log(''added location...'' + myURL);
//added location.../search?location=california
myURL = updateUrl(myURL,''location'',''new york'');
console.log(''updated location...'' + myURL);
//updated location.../search?location=new%20york
myURL = updateUrl(myURL,''location'');
console.log(''removed location...'' + myURL);
//removed location.../search
// ejemplo2
var myURL = ''/search?category=mobile'';
myURL = updateUrl(myURL,''location'',''california'');
console.log(''added location...'' + myURL);
//added location.../search?category=mobile&location=california
myURL = updateUrl(myURL,''location'',''new york'');
console.log(''updated location...'' + myURL);
//updated location.../search?category=mobile&location=new%20york
myURL = updateUrl(myURL,''location'');
console.log(''removed location...'' + myURL);
//removed location.../search?category=mobile
// ejemplo3
var myURL = ''/search?location=texas'';
myURL = updateUrl(myURL,''location'',''california'');
console.log(''updated location...'' + myURL);
//added location.../search?location=california
myURL = updateUrl(myURL,''location'',''new york'');
console.log(''updated location...'' + myURL);
//updated location.../search?location=new%20york
myURL = updateUrl(myURL,''location'');
console.log(''removed location...'' + myURL);
//removed location.../search
// ejemplo4
var myURL = ''/search?category=mobile&location=texas'';
myURL = updateUrl(myURL,''location'',''california'');
console.log(''updated location...'' + myURL);
//added location.../search?category=mobile&location=california
myURL = updateUrl(myURL,''location'',''new york'');
console.log(''updated location...'' + myURL);
//updated location.../search?category=mobile&location=new%20york
myURL = updateUrl(myURL,''location'');
console.log(''removed location...'' + myURL);
//removed location.../search?category=mobile
Aquí está la función
function updateUrl(url,key,value){
if(value!=undefined){
value = encodeURI(value);
}
var urls = url.split(''?'');
var baseUrl = urls[0];
var parameters = '''';
var outPara = {};
if(urls.length>1){
parameters = urls[1];
}
if(parameters!=''''){
parameters = parameters.split(''&'');
for(k in parameters){
var keyVal = parameters[k];
keyVal = keyVal.split(''='');
var ekey = keyVal[0];
var eval = '''';
if(keyVal.length>1){
eval = keyVal[1];
}
outPara[ekey] = eval;
}
}
if(value!=undefined){
outPara[key] = value;
}else{
delete outPara[key];
}
parameters = [];
for(var k in outPara){
parameters.push(k + ''='' + outPara[k]);
}
var finalUrl = baseUrl;
if(parameters.length>0){
finalUrl += ''?'' + parameters.join(''&'');
}
return finalUrl;
}
La solución más fácil, funciona si ya tiene una etiqueta o no, y la elimina automáticamente para que no siga agregando etiquetas iguales, diviértase
function changeURL(tag)
{
if(window.location.href.indexOf("?") > -1) {
if(window.location.href.indexOf("&"+tag) > -1){
var url = window.location.href.replace("&"+tag,"")+"&"+tag;
}
else
{
var url = window.location.href+"&"+tag;
}
}else{
if(window.location.href.indexOf("?"+tag) > -1){
var url = window.location.href.replace("?"+tag,"")+"?"+tag;
}
else
{
var url = window.location.href+"?"+tag;
}
}
window.location = url;
}
ENTONCES
changeURL("i=updated");
La solución más simple que puedo pensar es este método, que devolverá el URI modificado. Siento que la mayoría de ustedes está trabajando muy duro.
function setParam(uri, key, val) {
return uri
.replace(new RegExp("([?&]"+key+"(?=[=&#]|$)[^#&]*|(?=#|$))"), "&"+key+"="+encodeURIComponent(val))
.replace(/^([^?&]+)&/, "$1?");
}
Lo mejor que puedo decir es que ninguna de las respuestas anteriores aborda el caso donde la cadena de consulta contiene parámetros que a su vez son una matriz y, por lo tanto, aparecerán más de una vez, por ejemplo:
http://example.com?sizes[]=a&sizes[]=b
La siguiente función es lo que escribí para actualizar document.location.search . Toma una matriz de matrices de pares clave / valor como argumento y devolverá una versión revisada de la última, en la que puede hacer lo que quiera. Lo estoy usando así:
var newParams = [
[''test'',''123''],
[''best'',''456''],
[''sizes[]'',''XXL'']
];
var newUrl = document.location.pathname + insertParams(newParams);
history.replaceState('''', '''', newUrl);
Si la URL actual era:
http://example.com/index.php?test=replaceme&sizes[]=XL
Esto te atraparía
http://example.com/index.php?test=123&sizes[]=XL&sizes[]=XXL&best=456
Función
function insertParams(params) {
var result;
var ii = params.length;
var queryString = document.location.search.substr(1);
var kvps = queryString ? queryString.split(''&'') : [];
var kvp;
var skipParams = [];
var i = kvps.length;
while (i--) {
kvp = kvps[i].split(''='');
if (kvp[0].slice(-2) != ''[]'') {
var ii = params.length;
while (ii--) {
if (params[ii][0] == kvp[0]) {
kvp[1] = params[ii][1];
kvps[i] = kvp.join(''='');
skipParams.push(ii);
}
}
}
}
var ii = params.length;
while (ii--) {
if (skipParams.indexOf(ii) === -1) {
kvps.push(params[ii].join(''=''));
}
}
result = kvps.length ? ''?'' + kvps.join(''&'') : '''';
return result;
}
Me gusta la respuesta de Mehmet Fatih Yildiz, incluso él no respondió toda la pregunta.
En la misma línea que su respuesta, uso este código:
"No controla la existencia del parámetro, y no cambia el valor existente. Agrega tu parámetro al final"
/** add a parameter at the end of the URL. Manage ''?''/''&'', but not the existing parameters.
* does escape the value (but not the key)
*/
function addParameterToURL(_url,_key,_value){
var param = _key+''=''+escape(_value);
var sep = ''&'';
if (_url.indexOf(''?'') < 0) {
sep = ''?'';
} else {
var lastChar=_url.slice(-1);
if (lastChar == ''&'') sep='''';
if (lastChar == ''?'') sep='''';
}
_url += sep + param;
return _url;
}
y el probador:
/*
function addParameterToURL_TESTER_sub(_url,key,value){
//log(_url);
log(addParameterToURL(_url,key,value));
}
function addParameterToURL_TESTER(){
log(''-------------------'');
var _url =''www.google.com'';
addParameterToURL_TESTER_sub(_url,''key'',''value'');
addParameterToURL_TESTER_sub(_url,''key'',''Text Value'');
_url =''www.google.com?'';
addParameterToURL_TESTER_sub(_url,''key'',''value'');
_url =''www.google.com?A=B'';
addParameterToURL_TESTER_sub(_url,''key'',''value'');
_url =''www.google.com?A=B&'';
addParameterToURL_TESTER_sub(_url,''key'',''value'');
_url =''www.google.com?A=1&B=2'';
addParameterToURL_TESTER_sub(_url,''key'',''value'');
}//*/
Ok aquí comparo Dos funciones, una hecha por mí mismo (regExp) y otra hecha por (annakata).
Split array:
function insertParam(key, value)
{
key = escape(key); value = escape(value);
var kvp = document.location.search.substr(1).split(''&'');
var i=kvp.length; var x; while(i--)
{
x = kvp[i].split(''='');
if (x[0]==key)
{
x[1] = value;
kvp[i] = x.join(''='');
break;
}
}
if(i<0) {kvp[kvp.length] = [key,value].join(''='');}
//this will reload the page, it''s likely better to store this until finished
return "&"+kvp.join(''&'');
}
Método Regexp:
function addParameter(param, value)
{
var regexp = new RegExp("(//?|//&)" + param + "//=([^//&]*)(//&|$)");
if (regexp.test(document.location.search))
return (document.location.search.toString().replace(regexp, function(a, b, c, d)
{
return (b + param + "=" + value + d);
}));
else
return document.location.search+ param + "=" + value;
}
Caso de prueba:
time1=(new Date).getTime();
for (var i=0;i<10000;i++)
{
addParameter("test","test");
}
time2=(new Date).getTime();
for (var i=0;i<10000;i++)
{
insertParam("test","test");
}
time3=(new Date).getTime();
console.log((time2-time1)+" "+(time3-time2));
Parece que incluso con la solución más simple (cuando el uso de expresiones regulares solo prueba y no ingresa la función .replace) es aún más lento que el spliting ... Bueno. Regexp es un poco lento, pero ... uhh ...
Si estás jugando con las URL en enlaces o en otro lugar, es posible que también tengas que tener en cuenta el hash. Aquí hay una solución bastante simple de entender. Probablemente no sea el MÁS RÁPIDO ya que usa una expresión regular ... pero en el 99.999% de los casos, ¡la diferencia realmente no importa!
function addQueryParam( url, key, val ){
var parts = url.match(/([^?#]+)(/?[^#]*)?(/#.*)?/);
var url = parts[1];
var qs = parts[2] || '''';
var hash = parts[3] || '''';
if ( !qs ) {
return url + ''?'' + key + ''='' + encodeURIComponent( val ) + hash;
} else {
var qs_parts = qs.substr(1).split("&");
var i;
for (i=0;i<qs_parts.length;i++) {
var qs_pair = qs_parts[i].split("=");
if ( qs_pair[0] == key ){
qs_parts[ i ] = key + ''='' + encodeURIComponent( val );
break;
}
}
if ( i == qs_parts.length ){
qs_parts.push( key + ''='' + encodeURIComponent( val ) );
}
return url + ''?'' + qs_parts.join(''&'') + hash;
}
}
Si tiene una cadena con url que desea decorar con un param, puede intentar esto:
urlstring += ( urlstring.match( /[/?]/g ) ? ''&'' : ''?'' ) + ''param=value'';
Esto significa eso ? será el prefijo del parámetro, pero si ya tienes ? en urlstring , que & y será el prefijo.
También recomendaría hacer encodeURI( paramvariable ) si no has codificado el parámetro, pero está dentro de una paramvariable ; o si tienes personajes divertidos en él.
Consulte la codificación de JavaScript URL para el uso de la función encodeURI .
Tengo una ''clase'' que hace esto y aquí está:
function QS(){
this.qs = {};
var s = location.search.replace( /^/?|#.*$/g, '''' );
if( s ) {
var qsParts = s.split(''&'');
var i, nv;
for (i = 0; i < qsParts.length; i++) {
nv = qsParts[i].split(''='');
this.qs[nv[0]] = nv[1];
}
}
}
QS.prototype.add = function( name, value ) {
if( arguments.length == 1 && arguments[0].constructor == Object ) {
this.addMany( arguments[0] );
return;
}
this.qs[name] = value;
}
QS.prototype.addMany = function( newValues ) {
for( nv in newValues ) {
this.qs[nv] = newValues[nv];
}
}
QS.prototype.remove = function( name ) {
if( arguments.length == 1 && arguments[0].constructor == Array ) {
this.removeMany( arguments[0] );
return;
}
delete this.qs[name];
}
QS.prototype.removeMany = function( deleteNames ) {
var i;
for( i = 0; i < deleteNames.length; i++ ) {
delete this.qs[deleteNames[i]];
}
}
QS.prototype.getQueryString = function() {
var nv, q = [];
for( nv in this.qs ) {
q[q.length] = nv+''=''+this.qs[nv];
}
return q.join( ''&'' );
}
QS.prototype.toString = QS.prototype.getQueryString;
//examples
//instantiation
var qs = new QS;
alert( qs );
//add a sinle name/value
qs.add( ''new'', ''true'' );
alert( qs );
//add multiple key/values
qs.add( { x: ''X'', y: ''Y'' } );
alert( qs );
//remove single key
qs.remove( ''new'' )
alert( qs );
//remove multiple keys
qs.remove( [''x'', ''bogus''] )
alert( qs );
He reemplazado el método toString por lo que no es necesario llamar a QS :: getQueryString, puede usar QS :: toString o, como he hecho en los ejemplos, basarme en el objeto que se coacciona en una cadena.
Una implementación básica que deberá adaptar se vería así:
function insertParam(key, value)
{
key = encodeURI(key); value = encodeURI(value);
var kvp = document.location.search.substr(1).split(''&'');
var i=kvp.length; var x; while(i--)
{
x = kvp[i].split(''='');
if (x[0]==key)
{
x[1] = value;
kvp[i] = x.join(''='');
break;
}
}
if(i<0) {kvp[kvp.length] = [key,value].join(''='');}
//this will reload the page, it''s likely better to store this until finished
document.location.search = kvp.join(''&'');
}
Esto es aproximadamente el doble de rápido que una solución de expresión regular o búsqueda, pero eso depende completamente de la longitud de la cadena de consulta y el índice de cualquier coincidencia
el método lento de regex para el que hice una comparación por saciedad (aproximadamente + 150% más lento)
function insertParam2(key,value)
{
key = encodeURIComponent(key); value = encodeURIComponent(value);
var s = document.location.search;
var kvp = key+"="+value;
var r = new RegExp("(&|//?)"+key+"=[^/&]*");
s = s.replace(r,"$1"+kvp);
if(!RegExp.$1) {s += (s.length>0 ? ''&'' : ''?'') + kvp;};
//again, do what you will here
document.location.search = s;
}
Utilizando:
- https://developer.mozilla.org/en-US/docs/Web/API/URL
- https://developer.mozilla.org/fr/docs/Web/API/URLSearchParams
Ejemplo:
var url = new URL("http://foo.bar/?x=1&y=2");
// If your expected result is "http://foo.bar/?x=1&y=2&x=42"
url.searchParams.append(''x'', 42);
// If your expected result is "http://foo.bar/?x=42&y=2"
url.searchParams.set(''x'', 42);
Tratar
Las expresiones regulares, tan lentas, por lo tanto:
var SetParamUrl = function(_k, _v) {// replace and add new parameters
let arrParams = window.location.search !== '''' ? decodeURIComponent(window.location.search.substr(1)).split(''&'').map(_v => _v.split(''='')) : Array();
let index = arrParams.findIndex((_v) => _v[0] === _k);
index = index !== -1 ? index : arrParams.length;
_v === null ? arrParams = arrParams.filter((_v, _i) => _i != index) : arrParams[index] = [_k, _v];
let _search = encodeURIComponent(arrParams.map(_v => _v.join(''='')).join(''&''));
let newurl = window.location.protocol + "//" + window.location.host + window.location.pathname + (arrParams.length > 0 ? ''?'' + _search : '''');
// window.location = newurl; //reload
if (history.pushState) { // without reload
window.history.pushState({path:newurl}, null, newurl);
}
};
var GetParamUrl = function(_k) {// get parameter by key
let sPageURL = decodeURIComponent(window.location.search.substr(1)),
sURLVariables = sPageURL.split(''&'').map(_v => _v.split(''=''));
let _result = sURLVariables.find(_v => _v[0] === _k);
return _result[1];
};
Ejemplo:
// https://some.com/some_path
GetParamUrl(''cat'');//undefined
SetParamUrl(''cat'', "strData");// https://some.com/some_path?cat=strData
GetParamUrl(''cat'');//strData
SetParamUrl(''sotr'', "strDataSort");// https://some.com/some_path?cat=strData&sotr=strDataSort
GetParamUrl(''sotr'');//strDataSort
SetParamUrl(''cat'', "strDataTwo");// https://some.com/some_path?cat=strDataTwo&sotr=strDataSort
GetParamUrl(''cat'');//strDataTwo
//remove param
SetParamUrl(''cat'', null);// https://some.com/some_path?sotr=strDataSort
/**
* Add a URL parameter
* @param {string} url
* @param {string} param the key to set
* @param {string} value
*/
var addParam = function(url, param, value) {
param = encodeURIComponent(param);
var a = document.createElement(''a'');
param += (value ? "=" + encodeURIComponent(value) : "");
a.href = url;
a.search += (a.search ? "&" : "") + param;
return a.href;
}
/**
* Add a URL parameter (or modify if already exists)
* @param {string} url
* @param {string} param the key to set
* @param {string} value
*/
var addOrReplaceParam = function(url, param, value) {
param = encodeURIComponent(param);
var r = "([&?]|&)" + param + "//b(?:=(?:[^&#]*))*";
var a = document.createElement(''a'');
var regex = new RegExp(r);
var str = param + (value ? "=" + encodeURIComponent(value) : "");
a.href = url;
var q = a.search.replace(regex, "$1"+str);
if (q === a.search) {
a.search += (a.search ? "&" : "") + str;
} else {
a.search = q;
}
return a.href;
}
url = "http://www.example.com#hashme";
newurl = addParam(url, "ciao", "1");
alert(newurl);
Y tenga en cuenta que los parámetros deben codificarse antes de anexarse a la cadena de consulta.
var MyApp = new Class();
MyApp.extend({
utility: {
queryStringHelper: function (url) {
var originalUrl = url;
var newUrl = url;
var finalUrl;
var insertParam = function (key, value) {
key = escape(key);
value = escape(value);
//The previous post had the substr strat from 1 in stead of 0!!!
var kvp = newUrl.substr(0).split(''&'');
var i = kvp.length;
var x;
while (i--) {
x = kvp[i].split(''='');
if (x[0] == key) {
x[1] = value;
kvp[i] = x.join(''='');
break;
}
}
if (i < 0) {
kvp[kvp.length] = [key, value].join(''='');
}
finalUrl = kvp.join(''&'');
return finalUrl;
};
this.insertParameterToQueryString = insertParam;
this.insertParams = function (keyValues) {
for (var keyValue in keyValues[0]) {
var key = keyValue;
var value = keyValues[0][keyValue];
newUrl = insertParam(key, value);
}
return newUrl;
};
return this;
}
}
});