¿Puedes explicarme en qué se diferencian los dos siguientes?
jq ´def addvalue(f): . + [f]; map(addvalue(.[0]))´
[[1,2],[10,20]]
=> [[1,2,1], [10,20,10]]
jq ´def addvalue(f): f as $x | map(. + $x); addvalue(.[0])´
[[1,2],[10,20]]
=> [[1,2,1,2], [10,20,1,2]]
Gracias.
Respuesta1
Resumen: Las dos funciones y la forma en que se llaman difieren en dónde map()ocurre la operación y qué se usa en la suma. Esto importa ya que en el primer caso, map()en la llamada hace que la adición en la función use el primer elemento decada subconjunto individualde la matriz de entrada. En el segundo caso, map()se realiza dentro de la función y la suma se realiza utilizandotodo el primer subconjuntode la matriz de entrada.
En la primera función,
def addvalue(f): . + [f];
agrega la matriz [f]a lo que se supone que es una matriz en el flujo de entrada. Agregar una matriz a otra matriz tiene el efecto de agregar nuevos elementos a la matriz.
Llamas a esta addvalue()función dos veces usando map(); una vez para cada una de las matrices [1,2]y [10,20]. En la primera llamada, [f]será [1], por lo que lo agrega 1como un nuevo elemento en la primera matriz, lo que produce [1,2,1]. Asimismo, obtienes [10,20,10]a partir de la segunda convocatoria cuando [f]es [10].
Agregando depuración a la función,
def addvalue(f): debug | . + [f]
obtenemos lo siguiente al llamarlo como en la pregunta:
["DEBUG:",[1,2]]
["DEBUG:",[10,20]]
Esto muestra que la función se llama dos veces. El valor [f]estaría [1]en la primera llamada, dando como resultado la operación [1,2] + [1], dando [1,2,1], y [10]en la segunda llamada, dando como [10,20] + [10]resultado [10,20,10]. La map()operación en la llamada combinaría estas matrices en [[1,2,1],[10,20,10]].
en la funcion
def addvalue(f): f as $x | map(. + $x);
llamas map()a lo que se supone que es una matriz en el flujo de entrada. Para cada elemento en la matriz de entrada, agrega $xa ese elemento. El valor de $xes el primer elemento de la matriz.
Llamas a esta función una vez, con la matriz [[1,2],[10,20]]como matriz de entrada y [1,2]como argumento. Para cada uno de los elementos de la matriz de entrada, es decir, para [1,2]y [10,20], agrega [1,2](el valor de $x, el primer elemento de la matriz). Agregar una matriz a otra matriz tiene el efecto de agregar los elementos de las matrices entre sí, por lo que terminará con [1,2,1,2]y [10,20,1,2]como dos elementos de la matriz resultante.
Habilitando la depuración en la segunda función de manera similar a la primera,
def addvalue(f): debug | f as $x | map(. + $x);
obtenemos como salida
["DEBUG:",[[1,2],[10,20]]]
Esto muestra que la función se llama una sola vez. La map()operación crearía una matriz donde cada elemento de la matriz de entrada se [1,2]sumaría a sí mismo, dando [[1,2,1,2],[10,20,1,2]]como resultado.
Para que la primera función actúe como la segunda, tendrías que llamarla usando
.[0] as $x | map(addvalue($x[]))
Para que la segunda función actúe como la primera, tendrías que llamarla como
[ .[] as $x | [$x] | addvalue([$x[0]]) | add ]