Apakah ada cara untuk mendapatkan nama parameter fungsi dari suatu fungsi secara dinamis?

Katakanlah fungsi saya terlihat seperti ini:

function doSomething(param1, param2, .... paramN){
   // fill an array with the parameter name and value
   // some other code 
}

Sekarang, bagaimana cara saya mendapatkan daftar nama parameter dan nilainya ke dalam array dari dalam fungsi?

Fungsi berikut akan mengembalikan array nama parameter dari setiap fungsi yang diteruskan.

var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
var ARGUMENT_NAMES = /([^\s,]+)/g;
function getParamNames(func) {
  var fnStr = func.toString().replace(STRIP_COMMENTS, '');
  var result = fnStr.slice(fnStr.indexOf('(')+1, fnStr.indexOf(')')).match(ARGUMENT_NAMES);
  if(result === null)
     result = [];
  return result;
}

Contoh penggunaan:

getParamNames(getParamNames) // returns ['func']
getParamNames(function (a,b,c,d){}) // returns ['a','b','c','d']
getParamNames(function (a,/*b,c,*/d){}) // returns ['a','d']
getParamNames(function (){}) // returns []

Edit :

Dengan ditemukannya ES6 fungsi ini dapat tersandung oleh parameter default. Ini adalah peretasan cepat yang seharusnya bisa digunakan dalam kebanyakan kasus:

var STRIP_COMMENTS = /(\/\/.*$)|(\/\*[\s\S]*?\*\/)|(\s*=[^,\)]*(('(?:\\'|[^'\r\n])*')|("(?:\\"|[^"\r\n])*"))|(\s*=[^,\)]*))/mg;

Saya mengatakan sebagian besar kasus karena ada beberapa hal yang akan menjebaknya

function (a=4*(5/3), b) {} // returns ['a']

Sunting : Saya juga mencatat vikasde menginginkan nilai parameter dalam array juga. Ini sudah disediakan dalam variabel lokal bernama argumen.

kutipan dari https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments :

Objek argumen bukan Array. Ini mirip dengan Array, tetapi tidak memiliki properti Array kecuali panjang. Misalnya, tidak memiliki metode pop. Namun itu dapat dikonversi menjadi Array nyata:

var args = Array.prototype.slice.call(arguments);

Jika Array generics tersedia, seseorang dapat menggunakan yang berikut ini sebagai gantinya:

var args = Array.slice(arguments);

Di bawah ini adalah kode yang diambil dari AngularJS yang menggunakan teknik untuk mekanisme injeksi ketergantungannya.

Dan berikut ini penjelasannya diambil dari http://docs.angularjs.org/tutorial/step_05

Injector dependensi sudut menyediakan layanan untuk controller Anda ketika controller sedang dibangun. Injektor dependensi juga menangani pembuatan dependensi transitif apa pun yang mungkin dimiliki layanan (layanan sering bergantung pada layanan lain).

Perhatikan bahwa nama-nama argumen itu penting, karena injektor menggunakannya untuk mencari dependensi.

/**
 * @ngdoc overview
 * @name AUTO
 * @description
 *
 * Implicit module which gets automatically added to each {@link AUTO.$injector $injector}.
 */

var FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
var FN_ARG_SPLIT = /,/;
var FN_ARG = /^\s*(_?)(.+?)\1\s*$/;
var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
function annotate(fn) {
  var $inject,
      fnText,
      argDecl,
      last;

  if (typeof fn == 'function') {
    if (!($inject = fn.$inject)) {
      $inject = [];
      fnText = fn.toString().replace(STRIP_COMMENTS, '');
      argDecl = fnText.match(FN_ARGS);
      forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg){
        arg.replace(FN_ARG, function(all, underscore, name){
          $inject.push(name);
        });
      });
      fn.$inject = $inject;
    }
  } else if (isArray(fn)) {
    last = fn.length - 1;
    assertArgFn(fn[last], 'fn')
    $inject = fn.slice(0, last);
  } else {
    assertArgFn(fn, 'fn', true);
  }
  return $inject;
}

Berikut ini adalah solusi terbaru yang berupaya menangani semua kasus tepi yang disebutkan di atas dengan cara yang ringkas:

function $args(func) {  
    return (func + '')
      .replace(/[/][/].*$/mg,'') // strip single-line comments
      .replace(/\s+/g, '') // strip white space
      .replace(/[/][*][^/*]*[*][/]/g, '') // strip multi-line comments  
      .split('){', 1)[0].replace(/^[^(]*[(]/, '') // extract the parameters  
      .replace(/=[^,]+/g, '') // strip any ES6 defaults  
      .split(',').filter(Boolean); // split & filter [""]
}  

Output tes singkat (contoh uji lengkap terlampir di bawah):

'function (a,b,c)...' // returns ["a","b","c"]
'function ()...' // returns []
'function named(a, b, c) ...' // returns ["a","b","c"]
'function (a /* = 1 */, b /* = true */) ...' // returns ["a","b"]
'function fprintf(handle, fmt /*, ...*/) ...' // returns ["handle","fmt"]
'function( a, b = 1, c )...' // returns ["a","b","c"]
'function (a=4*(5/3), b) ...' // returns ["a","b"]
'function (a, // single-line comment xjunk) ...' // returns ["a","b"]
'function (a /* fooled you...' // returns ["a","b"]
'function (a /* function() yes */, \n /* no, */b)/* omg! */...' // returns ["a","b"]
'function ( A, b \n,c ,d \n ) \n ...' // returns ["A","b","c","d"]
'function (a,b)...' // returns ["a","b"]
'function $args(func) ...' // returns ["func"]
'null...' // returns ["null"]
'function Object() ...' // returns []

function $args(func) {  
    return (func + '')
      .replace(/[/][/].*$/mg,'') // strip single-line comments
      .replace(/\s+/g, '') // strip white space
      .replace(/[/][*][^/*]*[*][/]/g, '') // strip multi-line comments  
      .split('){', 1)[0].replace(/^[^(]*[(]/, '') // extract the parameters  
      .replace(/=[^,]+/g, '') // strip any ES6 defaults  
      .split(',').filter(Boolean); // split & filter [""]
}  

// test cases  
document.getElementById('console_info').innerHTML = (
[  
  // formatting -- typical  
  function(a,b,c){},  
  function(){},  
  function named(a, b,  c) {  
/* multiline body */  
  },  
    
  // default values -- conventional  
  function(a /* = 1 */, b /* = true */) { a = a||1; b=b||true; },  
  function fprintf(handle, fmt /*, ...*/) { },  
  
  // default values -- ES6  
  "function( a, b = 1, c ){}",  
  "function (a=4*(5/3), b) {}",  
  
  // embedded comments -- sardonic  
  function(a, // single-line comment xjunk) {}
    b //,c,d
  ) // single-line comment
  {},  
  function(a /* fooled you{*/,b){},  
  function /* are you kidding me? (){} */(a /* function() yes */,  
   /* no, */b)/* omg! */{/*}}*/},  
  
  // formatting -- sardonic  
  function  (  A,  b  
,c  ,d  
  )  
  {  
  },  
  
  // by reference  
  this.jQuery || function (a,b){return new e.fn.init(a,b,h)},
  $args,  
  
  // inadvertent non-function values  
  null,  
  Object  
].map(function(f) {
    var abbr = (f + '').replace(/\n/g, '\\n').replace(/\s+|[{]+$/g, ' ').split("{", 1)[0] + "...";
    return "    '" + abbr + "' // returns " + JSON.stringify($args(f));
  }).join("\n") + "\n"); // output for copy and paste as a markdown snippet

<pre id='console_info'></pre>

Solusi yang lebih sedikit rawan kesalahan terhadap spasi dan komentar adalah:

var fn = function(/* whoa) */ hi, you){};

fn.toString()
  .replace(/((\/\/.*$)|(\/\*[\s\S]*?\*\/)|(\s))/mg,'')
  .match(/^function\s*[^\(]*\(\s*([^\)]*)\)/m)[1]
  .split(/,/)

["hi", "you"]

Banyak jawaban di sini menggunakan regex, ini bagus tapi tidak terlalu baik untuk penambahan bahasa (seperti fungsi panah dan kelas). Yang juga perlu diperhatikan adalah bahwa jika Anda menggunakan salah satu dari fungsi ini pada kode yang diperkecil maka ia akan pergi 🔥. Itu akan menggunakan apa pun nama yang diperkecil itu. Sudut menyiasatinya dengan memungkinkan Anda untuk mengirimkan serangkaian string yang cocok dengan urutan argumen saat mendaftarkannya dengan wadah DI. Demikian seterusnya dengan solusinya:

var esprima = require('esprima');
var _ = require('lodash');

const parseFunctionArguments = (func) => {
    // allows us to access properties that may or may not exist without throwing 
    // TypeError: Cannot set property 'x' of undefined
    const maybe = (x) => (x || {});

    // handle conversion to string and then to JSON AST
    const functionAsString = func.toString();
    const tree = esprima.parse(functionAsString);
    console.log(JSON.stringify(tree, null, 4))
    // We need to figure out where the main params are. Stupid arrow functions 👊
    const isArrowExpression = (maybe(_.first(tree.body)).type == 'ExpressionStatement');
    const params = isArrowExpression ? maybe(maybe(_.first(tree.body)).expression).params 
                                     : maybe(_.first(tree.body)).params;

    // extract out the param names from the JSON AST
    return _.map(params, 'name');
};

Ini menangani masalah parse asli dan beberapa tipe fungsi lainnya (mis. Fungsi panah). Inilah gagasan tentang apa yang bisa dan tidak bisa ditangani sebagaimana adanya:

// I usually use mocha as the test runner and chai as the assertion library
describe('Extracts argument names from function signature. 💪', () => {
    const test = (func) => {
        const expectation = ['it', 'parses', 'me'];
        const result = parseFunctionArguments(toBeParsed);
        result.should.equal(expectation);
    } 

    it('Parses a function declaration.', () => {
        function toBeParsed(it, parses, me){};
        test(toBeParsed);
    });

    it('Parses a functional expression.', () => {
        const toBeParsed = function(it, parses, me){};
        test(toBeParsed);
    });

    it('Parses an arrow function', () => {
        const toBeParsed = (it, parses, me) => {};
        test(toBeParsed);
    });

    // ================= cases not currently handled ========================

    // It blows up on this type of messing. TBH if you do this it deserves to 
    // fail 😋 On a tech note the params are pulled down in the function similar 
    // to how destructuring is handled by the ast.
    it('Parses complex default params', () => {
        function toBeParsed(it=4*(5/3), parses, me) {}
        test(toBeParsed);
    });

    // This passes back ['_ref'] as the params of the function. The _ref is a 
    // pointer to an VariableDeclarator where the ✨🦄 happens.
    it('Parses object destructuring param definitions.' () => {
        function toBeParsed ({it, parses, me}){}
        test(toBeParsed);
    });

    it('Parses object destructuring param definitions.' () => {
        function toBeParsed ([it, parses, me]){}
        test(toBeParsed);
    });

    // Classes while similar from an end result point of view to function
    // declarations are handled completely differently in the JS AST. 
    it('Parses a class constructor when passed through', () => {
        class ToBeParsed {
            constructor(it, parses, me) {}
        }
        test(ToBeParsed);
    });
});

Bergantung pada apa yang ingin Anda gunakan untuk ES6 Proxy dan perusakan mungkin merupakan pilihan terbaik Anda. Misalnya jika Anda ingin menggunakannya untuk injeksi dependensi (menggunakan nama params) maka Anda dapat melakukannya sebagai berikut:

class GuiceJs {
    constructor() {
        this.modules = {}
    }
    resolve(name) {
        return this.getInjector()(this.modules[name]);
    }
    addModule(name, module) {
        this.modules[name] = module;
    }
    getInjector() {
        var container = this;

        return (klass) => {
            console.log(klass);
            var paramParser = new Proxy({}, {
                // The `get` handler is invoked whenever a get-call for
                // `injector.*` is made. We make a call to an external service
                // to actually hand back in the configured service. The proxy
                // allows us to bypass parsing the function params using
                // taditional regex or even the newer parser.
                get: (target, name) => container.resolve(name),

                // You shouldn't be able to set values on the injector.
                set: (target, name, value) => {
                    throw new Error(`Don't try to set ${name}! 😑`);
                }
            })
            return new klass(paramParser);
        }
    }
}

Ini bukan resolver paling canggih di luar sana tetapi memberikan gambaran tentang bagaimana Anda dapat menggunakan Proxy untuk menanganinya jika Anda ingin menggunakan args parser untuk DI sederhana. Namun ada satu peringatan kecil dalam pendekatan ini. Kita perlu menggunakan penugasan yang merusak alih-alih params yang normal. Ketika kami melewati proxy injector, destrukturisasi sama dengan memanggil pengambil pada objek.

class App {
   constructor({tweeter, timeline}) {
        this.tweeter = tweeter;
        this.timeline = timeline;
    }
}

class HttpClient {}

class TwitterApi {
    constructor({client}) {
        this.client = client;
    }
}

class Timeline {
    constructor({api}) {
        this.api = api;
    }
}

class Tweeter {
    constructor({api}) {
        this.api = api;
    }
}

// Ok so now for the business end of the injector!
const di = new GuiceJs();

di.addModule('client', HttpClient);
di.addModule('api', TwitterApi);
di.addModule('tweeter', Tweeter);
di.addModule('timeline', Timeline);
di.addModule('app', App);

var app = di.resolve('app');
console.log(JSON.stringify(app, null, 4));

Ini menghasilkan sebagai berikut:

{
    "tweeter": {
        "api": {
            "client": {}
        }
    },
    "timeline": {
        "api": {
            "client": {}
        }
    }
}

Ini menghubungkan seluruh aplikasi. Bit terbaik adalah bahwa aplikasi ini mudah untuk diuji (Anda bisa langsung membuat instance setiap kelas dan lulus mengejek / bertopik / dll). Juga jika Anda perlu menukar implementasi, Anda dapat melakukannya dari satu tempat. Semua ini dimungkinkan karena objek JS Proxy.

Catatan: Ada banyak pekerjaan yang perlu dilakukan untuk ini sebelum akan siap untuk penggunaan produksi tetapi itu memberikan gambaran seperti apa bentuknya.

Ini agak terlambat dalam jawabannya tetapi mungkin membantu orang lain yang memikirkan hal yang sama. 👍

Saya tahu ini adalah pertanyaan lama, tetapi pemula telah meniru ini seolah-olah ini adalah praktik yang baik dalam kode apa pun. Sebagian besar waktu, harus mengurai representasi string fungsi untuk menggunakan nama parameternya hanya menyembunyikan kesalahan dalam logika kode.

Parameter fungsi sebenarnya disimpan dalam objek mirip array yang disebut arguments, di mana argumen pertama adalah arguments[0], yang kedua adalah arguments[1]dan seterusnya. Menulis nama parameter dalam tanda kurung dapat dilihat sebagai sintaks steno. Ini:

function doSomething(foo, bar) {
    console.log("does something");
}

...sama dengan:

function doSomething() {
    var foo = arguments[0];
    var bar = arguments[1];

    console.log("does something");
}

Variabel itu sendiri disimpan dalam ruang lingkup fungsi, bukan sebagai properti dalam objek. Tidak ada cara untuk mengambil nama parameter melalui kode karena itu hanya simbol yang mewakili variabel dalam bahasa manusia.

Saya selalu menganggap representasi string dari fungsi sebagai alat untuk keperluan debugging, terutama karena argumentsobjek seperti array ini . Anda tidak diharuskan untuk memberikan nama pada argumen di tempat pertama. Jika Anda mencoba mem-parsing fungsi yang dirangkai, itu tidak benar-benar memberi tahu Anda tentang parameter tambahan tanpa nama yang mungkin diperlukan.

Inilah situasi yang bahkan lebih buruk dan lebih umum. Jika suatu fungsi memiliki lebih dari 3 atau 4 argumen, mungkin logis untuk meneruskannya sebagai objek, yang lebih mudah untuk dikerjakan.

function saySomething(obj) {
  if(obj.message) console.log((obj.sender || "Anon") + ": " + obj.message);
}

saySomething({sender: "user123", message: "Hello world"});

Dalam hal ini, fungsi itu sendiri akan dapat membaca objek yang diterimanya dan mencari propertinya serta mendapatkan nama dan nilainya, tetapi mencoba mengurai representasi string dari fungsi tersebut hanya akan memberi Anda "keberatan" untuk parameter, yang tidak berguna sama sekali.

Karena JavaScript adalah bahasa scripting, saya merasa bahwa introspeksinya harus mendukung mendapatkan nama parameter fungsi. Punting pada fungsionalitas itu merupakan pelanggaran prinsip pertama, jadi saya memutuskan untuk mengeksplorasi masalah lebih lanjut.

Itu mengarahkan saya ke pertanyaan ini tetapi tidak ada solusi bawaan. Yang mengarahkan saya ke jawaban ini yang menjelaskan bahwa argumentshanya usang di luar fungsi, sehingga kami tidak dapat lagi menggunakan myFunction.argumentsatau mendapatkan:

TypeError: 'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them

Saatnya menyingsingkan lengan baju kami dan mulai bekerja:

⭐ Mengambil parameter fungsi memerlukan parser karena ekspresi kompleks seperti 4*(5/3)dapat digunakan sebagai nilai default. Jadi jawaban Gaafar atau jawaban James Drew sejauh ini merupakan pendekatan terbaik.

Saya mencoba parser babylon dan esprima tetapi sayangnya mereka tidak dapat mengurai fungsi anonim yang berdiri sendiri, seperti yang ditunjukkan dalam jawaban Mateusz Charytoniuk . Saya menemukan solusi lain dengan mengelilingi kode di dalam tanda kurung, agar tidak mengubah logika:

const ast = parser.parse("(\n" + func.toString() + "\n)")

Baris baru mencegah masalah dengan //(komentar satu baris).

⭐ Jika parser tidak tersedia, opsi terbaik berikutnya adalah menggunakan teknik coba-dan-benar seperti Angular.js's dependency injector regular expressions. Saya menggabungkan versi fungsional jawaban Lambder dengan jawaban humbletim dan menambahkan ARROWboolean opsional untuk mengendalikan apakah fungsi panah lemak ES6 diizinkan oleh ekspresi reguler.

Berikut adalah dua solusi yang saya kumpulkan. Perhatikan bahwa ini tidak memiliki logika untuk mendeteksi apakah suatu fungsi memiliki sintaks yang valid, mereka hanya mengekstrak argumen. Ini biasanya ok karena kita biasanya melewatkan fungsi yang diuraikan getArguments()sehingga sintaksnya sudah valid.

Saya akan mencoba mengumpulkan solusi ini sebaik mungkin, tetapi tanpa upaya dari pengelola JavaScript, ini akan tetap menjadi masalah terbuka.

Versi Node.js (tidak dapat dijalankan hingga StackOverflow mendukung Node.js):

const parserName = 'babylon';
// const parserName = 'esprima';
const parser = require(parserName);

function getArguments(func) {
    const maybe = function (x) {
        return x || {}; // optionals support
    }

    try {
        const ast = parser.parse("(\n" + func.toString() + "\n)");
        const program = parserName == 'babylon' ? ast.program : ast;

        return program
            .body[0]
            .expression
            .params
            .map(function(node) {
                return node.name || maybe(node.left).name || '...' + maybe(node.argument).name;
            });
    } catch (e) {
        return []; // could also return null
    }
};

////////// TESTS //////////

function logArgs(func) {
	let object = {};

	object[func] = getArguments(func);

	console.log(object);
// 	console.log(/*JSON.stringify(*/getArguments(func)/*)*/);
}

console.log('');
console.log('////////// MISC //////////');

logArgs((a, b) => {});
logArgs((a, b = 1) => {});
logArgs((a, b, ...args) => {});
logArgs(function(a, b, ...args) {});
logArgs(function(a, b = 1, c = 4 * (5 / 3), d = 2) {});
logArgs(async function(a, b, ...args) {});
logArgs(function async(a, b, ...args) {});

console.log('');
console.log('////////// FUNCTIONS //////////');

logArgs(function(a, b, c) {});
logArgs(function() {});
logArgs(function named(a, b, c) {});
logArgs(function(a /* = 1 */, b /* = true */) {});
logArgs(function fprintf(handle, fmt /*, ...*/) {});
logArgs(function(a, b = 1, c) {});
logArgs(function(a = 4 * (5 / 3), b) {});
// logArgs(function (a, // single-line comment xjunk) {});
// logArgs(function (a /* fooled you {});
// logArgs(function (a /* function() yes */, \n /* no, */b)/* omg! */ {});
// logArgs(function ( A, b \n,c ,d \n ) \n {});
logArgs(function(a, b) {});
logArgs(function $args(func) {});
logArgs(null);
logArgs(function Object() {});

console.log('');
console.log('////////// STRINGS //////////');

logArgs('function (a,b,c) {}');
logArgs('function () {}');
logArgs('function named(a, b, c) {}');
logArgs('function (a /* = 1 */, b /* = true */) {}');
logArgs('function fprintf(handle, fmt /*, ...*/) {}');
logArgs('function( a, b = 1, c ) {}');
logArgs('function (a=4*(5/3), b) {}');
logArgs('function (a, // single-line comment xjunk) {}');
logArgs('function (a /* fooled you {}');
logArgs('function (a /* function() yes */, \n /* no, */b)/* omg! */ {}');
logArgs('function ( A, b \n,c ,d \n ) \n {}');
logArgs('function (a,b) {}');
logArgs('function $args(func) {}');
logArgs('null');
logArgs('function Object() {}');

Contoh kerja penuh:

https://repl.it/repls/SandybrownPhonyAngles

Versi browser (perhatikan bahwa ia berhenti pada nilai default kompleks pertama):

function getArguments(func) {
    const ARROW = true;
    const FUNC_ARGS = ARROW ? /^(function)?\s*[^\(]*\(\s*([^\)]*)\)/m : /^(function)\s*[^\(]*\(\s*([^\)]*)\)/m;
    const FUNC_ARG_SPLIT = /,/;
    const FUNC_ARG = /^\s*(_?)(.+?)\1\s*$/;
    const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;

    return ((func || '').toString().replace(STRIP_COMMENTS, '').match(FUNC_ARGS) || ['', '', ''])[2]
        .split(FUNC_ARG_SPLIT)
        .map(function(arg) {
            return arg.replace(FUNC_ARG, function(all, underscore, name) {
                return name.split('=')[0].trim();
            });
        })
        .filter(String);
}

////////// TESTS //////////

function logArgs(func) {
	let object = {};

	object[func] = getArguments(func);

	console.log(object);
// 	console.log(/*JSON.stringify(*/getArguments(func)/*)*/);
}

console.log('');
console.log('////////// MISC //////////');

logArgs((a, b) => {});
logArgs((a, b = 1) => {});
logArgs((a, b, ...args) => {});
logArgs(function(a, b, ...args) {});
logArgs(function(a, b = 1, c = 4 * (5 / 3), d = 2) {});
logArgs(async function(a, b, ...args) {});
logArgs(function async(a, b, ...args) {});

console.log('');
console.log('////////// FUNCTIONS //////////');

logArgs(function(a, b, c) {});
logArgs(function() {});
logArgs(function named(a, b, c) {});
logArgs(function(a /* = 1 */, b /* = true */) {});
logArgs(function fprintf(handle, fmt /*, ...*/) {});
logArgs(function(a, b = 1, c) {});
logArgs(function(a = 4 * (5 / 3), b) {});
// logArgs(function (a, // single-line comment xjunk) {});
// logArgs(function (a /* fooled you {});
// logArgs(function (a /* function() yes */, \n /* no, */b)/* omg! */ {});
// logArgs(function ( A, b \n,c ,d \n ) \n {});
logArgs(function(a, b) {});
logArgs(function $args(func) {});
logArgs(null);
logArgs(function Object() {});

console.log('');
console.log('////////// STRINGS //////////');

logArgs('function (a,b,c) {}');
logArgs('function () {}');
logArgs('function named(a, b, c) {}');
logArgs('function (a /* = 1 */, b /* = true */) {}');
logArgs('function fprintf(handle, fmt /*, ...*/) {}');
logArgs('function( a, b = 1, c ) {}');
logArgs('function (a=4*(5/3), b) {}');
logArgs('function (a, // single-line comment xjunk) {}');
logArgs('function (a /* fooled you {}');
logArgs('function (a /* function() yes */, \n /* no, */b)/* omg! */ {}');
logArgs('function ( A, b \n,c ,d \n ) \n {}');
logArgs('function (a,b) {}');
logArgs('function $args(func) {}');
logArgs('null');
logArgs('function Object() {}');

Contoh kerja penuh:

https://repl.it/repls/StupendousShowyOffices

Saya telah membaca sebagian besar jawabannya di sini, dan saya ingin menambahkan satu kalimat.

new RegExp('(?:'+Function.name+'\\s*|^)\\((.*?)\\)').exec(Function.toString().replace(/\n/g, ''))[1].replace(/\/\*.*?\*\//g, '').replace(/ /g, '')

atau

function getParameters(func) {
  return new RegExp('(?:'+func.name+'\\s*|^)\\s*\\((.*?)\\)').exec(func.toString().replace(/\n/g, ''))[1].replace(/\/\*.*?\*\//g, '').replace(/ /g, '');
}

atau untuk fungsi satu-liner di ECMA6

var getParameters = func => new RegExp('(?:'+func.name+'\\s*|^)\\s*\\((.*?)\\)').exec(func.toString().replace(/\n/g, ''))[1].replace(/\/\*.*?\*\//g, '').replace(/ /g, '');

__

Katakanlah Anda memiliki fungsi

function foo(abc, def, ghi, jkl) {
  //code
}

Kode di bawah ini akan kembali "abc,def,ghi,jkl"

Kode itu juga akan berfungsi dengan pengaturan fungsi yang diberikan Camilo Martin :

function  (  A,  b
,c      ,d
){}

Juga dengan komentar Bubersson tentang jawaban Jack Allan :

function(a /* fooled you)*/,b){}

__

Penjelasan

new RegExp('(?:'+Function.name+'\\s*|^)\\s*\\((.*?)\\)')

Ini menciptakan Ekspresi Reguler dengan new RegExp('(?:'+Function.name+'\\s*|^)\\s*\\((.*?)\\)'). Saya harus menggunakan new RegExpkarena saya menyuntikkan variabel ( Function.name, nama fungsi yang ditargetkan) ke dalam RegExp.

Contoh Jika nama fungsi adalah "foo" ( function foo()), RegExp akan menjadi /foo\s*\((.*?)\)/.

Function.toString().replace(/\n/g, '')

Kemudian itu mengubah seluruh fungsi menjadi string, dan menghapus semua baris baru. Menghapus baris baru membantu pengaturan fungsi yang diberikan Camilo Martin .

.exec(...)[1]

Ini RegExp.prototype.execfungsinya. Ini pada dasarnya cocok dengan Eksponen Reguler ( new RegExp()) ke dalam String ( Function.toString()). Kemudian [1]akan mengembalikan Kelompok Pengambilan pertama yang ditemukan dalam Eksponen Reguler ( (.*?)).

.replace(/\/\*.*?\*\//g, '').replace(/ /g, '')

Ini akan menghapus setiap komentar di dalam /*dan */, dan menghapus semua spasi.

Ini juga sekarang mendukung =>fungsi membaca dan memahami tanda panah ( ), seperti f = (a, b) => void 0;, yang Function.toString()akan mengembalikan (a, b) => void 0fungsi yang normal function f(a, b) { return void 0; }. Ekspresi reguler asli akan membuat kesalahan dalam kebingungannya, tetapi sekarang diperhitungkan.

Perubahan adalah dari new RegExp(Function.name+'\\s*\\((.*?)\\)')( /Function\s*\((.*?)\)/) ke new RegExp('(?:'+Function.name+'\\s*|^)\\((.*?)\\)')( /(?:Function\s*|^)\((.*?)\)/)

Jika Anda ingin menjadikan semua parameter menjadi Array alih-alih String yang dipisahkan oleh koma, pada akhirnya tambahkan saja .split(',').

(function(a,b,c){}).toString().replace(/.*\(|\).*/ig,"").split(',')

=> ["a", "b", "c"]

Anda juga dapat menggunakan parser "esprima" untuk menghindari banyak masalah dengan komentar, spasi putih, dan hal-hal lain di dalam daftar parameter.

function getParameters(yourFunction) {
    var i,
        // safetyValve is necessary, because sole "function () {...}"
        // is not a valid syntax
        parsed = esprima.parse("safetyValve = " + yourFunction.toString()),
        params = parsed.body[0].expression.right.params,
        ret = [];

    for (i = 0; i < params.length; i += 1) {
        // Handle default params. Exe: function defaults(a = 0,b = 2,c = 3){}
        if (params[i].type == 'AssignmentPattern') {
            ret.push(params[i].left.name)
        } else {
            ret.push(params[i].name);
        }
    }

    return ret;
}

Ia bekerja bahkan dengan kode seperti ini:

getParameters(function (hello /*, foo ),* /bar* { */,world) {}); // ["hello", "world"]

Saya sudah mencoba melakukan ini sebelumnya, tetapi tidak pernah menemukan cara praktis untuk menyelesaikannya. Saya akhirnya melewati sebuah objek dan kemudian mengulanginya.

//define like
function test(args) {
    for(var item in args) {
        alert(item);
        alert(args[item]);
    }
}

//then used like
test({
    name:"Joe",
    age:40,
    admin:bool
});

Saya tidak tahu apakah solusi ini sesuai dengan masalah Anda, tetapi ini memungkinkan Anda mendefinisikan kembali fungsi apa pun yang Anda inginkan, tanpa harus mengubah kode yang menggunakannya. Panggilan yang ada akan menggunakan params yang diposisikan, sedangkan implementasi fungsi dapat menggunakan "params bernama" (parameter hash tunggal).

Saya pikir Anda akan tetap memodifikasi definisi fungsi yang ada jadi, mengapa tidak memiliki fungsi pabrik yang membuat apa yang Anda inginkan:

<!DOCTYPE html>

<html>
<head>
<meta charset="UTF-8">
<title></title>
<script type="text/javascript">
var withNamedParams = function(params, lambda) {
    return function() {
        var named = {};
        var max   = arguments.length;

        for (var i=0; i<max; i++) {
            named[params[i]] = arguments[i];
        }

        return lambda(named);
    };
};

var foo = withNamedParams(["a", "b", "c"], function(params) {
    for (var param in params) {
        alert(param + ": " + params[param]);
    }
});

foo(1, 2, 3);
</script>
</head>
<body>

</body>
</html>

Semoga ini bisa membantu.

Cara yang tepat untuk melakukan ini adalah dengan menggunakan parser JS. Berikut ini adalah contoh menggunakan biji .

const acorn = require('acorn');    

function f(a, b, c) {
   // ...
}

const argNames = acorn.parse(f).body[0].params.map(x => x.name);
console.log(argNames);  // Output: [ 'a', 'b', 'c' ]

Kode di sini menemukan nama-nama dari tiga (formal) parameter fungsi f. Ia melakukannya dengan memberi makan fke dalam acorn.parse().

Saya tidak tahu cara mendapatkan daftar parameter tetapi Anda dapat melakukan ini untuk mendapatkan berapa banyak yang diharapkan.

alert(doSomething.length);

Mengambil jawaban dari @ jack-allan saya memodifikasi fungsi sedikit untuk memungkinkan properti default ES6 seperti:

function( a, b = 1, c ){};

masih kembali [ 'a', 'b' ]

/**
 * Get the keys of the paramaters of a function.
 *
 * @param {function} method  Function to get parameter keys for
 * @return {array}
 */
var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
var ARGUMENT_NAMES = /(?:^|,)\s*([^\s,=]+)/g;
function getFunctionParameters ( func ) {
    var fnStr = func.toString().replace(STRIP_COMMENTS, '');
    var argsList = fnStr.slice(fnStr.indexOf('(')+1, fnStr.indexOf(')'));
    var result = argsList.match( ARGUMENT_NAMES );

    if(result === null) {
        return [];
    }
    else {
        var stripped = [];
        for ( var i = 0; i < result.length; i++  ) {
            stripped.push( result[i].replace(/[\s,]/g, '') );
        }
        return stripped;
    }
}

Bagaimana saya biasanya melakukannya:

function name(arg1, arg2){
    var args = arguments; // array: [arg1, arg2]
    var objecArgOne = args[0].one;
}
name({one: "1", two: "2"}, "string");

Anda bahkan dapat ref argumen dengan nama fungsi seperti:

name.arguments;

Semoga ini membantu!

//See this:


// global var, naming bB
var bB = 5;

//  Dependency Injection cokntroller
var a = function(str, fn) {
  //stringify function body
  var fnStr = fn.toString();

  // Key: get form args to string
  var args = fnStr.match(/function\s*\((.*?)\)/);
  // 
  console.log(args);
  // if the form arg is 'bB', then exec it, otherwise, do nothing
  for (var i = 0; i < args.length; i++) {
    if(args[i] == 'bB') {
      fn(bB);
    }
  }
}
// will do nothing
a('sdfdfdfs,', function(some){
alert(some)
});
// will alert 5

a('sdfdsdsfdfsdfdsf,', function(bB){
alert(bB)
});

// see, this shows you how to get function args in string

Jawaban untuk ini membutuhkan 3 langkah:

1. Untuk mendapatkan nilai parameter aktual yang diteruskan ke fungsi (sebut saja argValues). Ini lurus ke depan karena akan tersedia argumentsdi dalam fungsi.
2. Untuk mendapatkan nama parameter dari tanda tangan fungsi (sebut saja itu argNames ). Ini tidak semudah dan membutuhkan parsing fungsi. Alih-alih melakukan regex kompleks sendiri dan khawatir tentang kasus tepi (parameter default, komentar, ...), Anda dapat menggunakan perpustakaan seperti babylon yang akan menguraikan fungsi menjadi pohon sintaksis abstrak dari mana Anda dapat memperoleh nama-nama parameter.
3. Langkah terakhir adalah menggabungkan 2 array menjadi 1 array yang memiliki nama dan nilai semua parameter.

Kode akan seperti ini

const babylon = require("babylon")
function doSomething(a, b, c) {
    // get the values of passed argumenst
    const argValues = arguments

    // get the names of the arguments by parsing the function
    const ast = babylon.parse(doSomething.toString())
    const argNames =  ast.program.body[0].params.map(node => node.name)

    // join the 2 arrays, by looping over the longest of 2 arrays
    const maxLen = Math.max(argNames.length, argValues.length)
    const args = []
    for (i = 0; i < maxLen; i++) { 
       args.push({name: argNames[i], value: argValues[i]})
    }
    console.log(args)

    // implement the actual function here
}

doSomething(1, 2, 3, 4)

dan objek yang dicatat adalah

[
  {
    "name": "a",
    "value": 1
  },
  {
    "name": "c",
    "value": 3
  },
  {
    "value": 4
  }
]

Dan inilah contoh yang berfungsi https://tonicdev.com/5763eb77a945f41300f62a79/5763eb77a945f41300f62a7a

function getArgs(args) {
    var argsObj = {};

    var argList = /\(([^)]*)/.exec(args.callee)[1];
    var argCnt = 0;
    var tokens;

    while (tokens = /\s*([^,]+)/g.exec(argList)) {
        argsObj[tokens[1]] = args[argCnt++];
    }

    return argsObj;
}

Wow sudah banyak jawaban .. Saya cukup yakin ini terkubur. Meski begitu saya pikir ini mungkin berguna untuk beberapa orang.

Saya tidak sepenuhnya puas dengan jawaban yang dipilih seperti pada ES6 tidak bekerja dengan baik dengan nilai default. Dan itu juga tidak memberikan informasi nilai default. Saya juga menginginkan fungsi yang ringan yang tidak bergantung pada lib eksternal.

Fungsi ini sangat berguna untuk keperluan debugging, misalnya: mencatat fungsi yang dipanggil dengan params, nilai-nilai param default dan argumen.

Saya menghabiskan beberapa waktu untuk ini kemarin, memecahkan RegExp yang tepat untuk menyelesaikan masalah ini dan inilah yang saya temukan. Ini bekerja dengan sangat baik dan saya sangat senang dengan hasilnya:

const REGEX_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
const REGEX_FUNCTION_PARAMS = /(?:\s*(?:function\s*[^(]*)?\s*)((?:[^'"]|(?:(?:(['"])(?:(?:.*?[^\\]\2)|\2))))*?)\s*(?=(?:=>)|{)/m
const REGEX_PARAMETERS_VALUES = /\s*(\w+)\s*(?:=\s*((?:(?:(['"])(?:\3|(?:.*?[^\\]\3)))((\s*\+\s*)(?:(?:(['"])(?:\6|(?:.*?[^\\]\6)))|(?:[\w$]*)))*)|.*?))?\s*(?:,|$)/gm

/**
 * Retrieve a function's parameter names and default values
 * Notes:
 *  - parameters with default values will not show up in transpiler code (Babel) because the parameter is removed from the function.
 *  - does NOT support inline arrow functions as default values
 *      to clarify: ( name = "string", add = defaultAddFunction )   - is ok
 *                  ( name = "string", add = ( a )=> a + 1 )        - is NOT ok
 *  - does NOT support default string value that are appended with a non-standard ( word characters or $ ) variable name
 *      to clarify: ( name = "string" + b )         - is ok
 *                  ( name = "string" + $b )        - is ok
 *                  ( name = "string" + b + "!" )   - is ok
 *                  ( name = "string" + λ )         - is NOT ok
 * @param {function} func
 * @returns {Array} - An array of the given function's parameter [key, default value] pairs.
 */
function getParams(func) {

  let functionAsString = func.toString()
  let params = []
  let match
  functionAsString = functionAsString.replace(REGEX_COMMENTS, '')
  functionAsString = functionAsString.match(REGEX_FUNCTION_PARAMS)[1]
  if (functionAsString.charAt(0) === '(') functionAsString = functionAsString.slice(1, -1)
  while (match = REGEX_PARAMETERS_VALUES.exec(functionAsString)) params.push([match[1], match[2]])
  return params

}



// Lets run some tests!

var defaultName = 'some name'

function test1(param1, param2, param3) { return (param1) => param1 + param2 + param3 }
function test2(param1, param2 = 4 * (5 / 3), param3) {}
function test3(param1, param2 = "/root/" + defaultName + ".jpeg", param3) {}
function test4(param1, param2 = (a) => a + 1) {}

console.log(getParams(test1)) 
console.log(getParams(test2))
console.log(getParams(test3))
console.log(getParams(test4))

// [ [ 'param1', undefined ], [ 'param2', undefined ], [ 'param3', undefined ] ]
// [ [ 'param1', undefined ], [ 'param2', '4 * (5 / 3)' ], [ 'param3', undefined ] ]
// [ [ 'param1', undefined ], [ 'param2', '"/root/" + defaultName + ".jpeg"' ], [ 'param3', undefined ] ]
// [ [ 'param1', undefined ], [ 'param2', '( a' ] ]
// --> This last one fails because of the inlined arrow function!


var arrowTest1 = (a = 1) => a + 4
var arrowTest2 = a => b => a + b
var arrowTest3 = (param1 = "/" + defaultName) => { return param1 + '...' }
var arrowTest4 = (param1 = "/" + defaultName, param2 = 4, param3 = null) => { () => param3 ? param3 : param2 }

console.log(getParams(arrowTest1))
console.log(getParams(arrowTest2))
console.log(getParams(arrowTest3))
console.log(getParams(arrowTest4))

// [ [ 'a', '1' ] ]
// [ [ 'a', undefined ] ]
// [ [ 'param1', '"/" + defaultName' ] ]
// [ [ 'param1', '"/" + defaultName' ], [ 'param2', '4' ], [ 'param3', 'null' ] ]


console.log(getParams((param1) => param1 + 1))
console.log(getParams((param1 = 'default') => { return param1 + '.jpeg' }))

// [ [ 'param1', undefined ] ]
// [ [ 'param1', '\'default\'' ] ]

Seperti yang Anda tahu beberapa nama parameter menghilang karena Babel transpiler menghapusnya dari fungsi. Jika Anda akan menjalankan ini di NodeJS terbaru itu berfungsi seperti yang diharapkan (Hasil komentar dari NodeJS).

Catatan lain, seperti yang dinyatakan dalam komentar adalah bahwa tidak berfungsi dengan fungsi panah sebaris sebagai nilai default. Ini hanya membuatnya menjadi jauh lebih kompleks untuk mengekstraksi nilai menggunakan RegExp.

Tolong beri tahu saya jika ini bermanfaat bagi Anda! Senang mendengar umpan balik!

Saya akan memberi Anda contoh singkat di bawah ini:

function test(arg1,arg2){
    var funcStr = test.toString()
    var leftIndex = funcStr.indexOf('(');
    var rightIndex = funcStr.indexOf(')');
    var paramStr = funcStr.substr(leftIndex+1,rightIndex-leftIndex-1);
    var params = paramStr.split(',');
    for(param of params){
        console.log(param);   // arg1,arg2
    }
}

test();

Paket ini menggunakan penyusunan ulang untuk membuat AST dan kemudian nama parameter dikumpulkan dari mereka, ini memungkinkannya untuk mendukung pencocokan pola, argumen default, fungsi panah dan fitur ES6 lainnya.

https://www.npmjs.com/package/es-arguments

Saya telah memodifikasi versi yang diambil dari AngularJS yang mengimplementasikan mekanisme injeksi dependensi untuk bekerja tanpa Angular. Saya juga telah memperbarui STRIP_COMMENTSregex untuk bekerja ECMA6, sehingga mendukung hal-hal seperti nilai default pada tanda tangan.

var FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
var FN_ARG_SPLIT = /,/;
var FN_ARG = /^\s*(_?)(.+?)\1\s*$/;
var STRIP_COMMENTS = /(\/\/.*$)|(\/\*[\s\S]*?\*\/)|(\s*=[^,\)]*(('(?:\\'|[^'\r\n])*')|("(?:\\"|[^"\r\n])*"))|(\s*=[^,\)]*))/mg;

function annotate(fn) {
  var $inject,
    fnText,
    argDecl,
    last;

  if (typeof fn == 'function') {
    if (!($inject = fn.$inject)) {
      $inject = [];
      fnText = fn.toString().replace(STRIP_COMMENTS, '');
      argDecl = fnText.match(FN_ARGS);
      argDecl[1].split(FN_ARG_SPLIT).forEach(function(arg) {
        arg.replace(FN_ARG, function(all, underscore, name) {
          $inject.push(name);
        });
      });
      fn.$inject = $inject;
    }
  } else {
    throw Error("not a function")
  }
  return $inject;
}

console.log("function(a, b)",annotate(function(a, b) {
  console.log(a, b, c, d)
}))
console.log("function(a, b = 0, /*c,*/ d)",annotate(function(a, b = 0, /*c,*/ d) {
  console.log(a, b, c, d)
}))
annotate({})

Anda dapat mengakses nilai argumen yang diteruskan ke fungsi menggunakan properti "argumen".

    function doSomething()
    {
        var args = doSomething.arguments;
        var numArgs = args.length;
        for(var i = 0 ; i < numArgs ; i++)
        {
            console.log("arg " + (i+1) + " = " + args[i]);  
                    //console.log works with firefox + firebug
                    // you can use an alert to check in other browsers
        }
    }

    doSomething(1, '2', {A:2}, [1,2,3]);    

Cukup mudah.

Pada awalnya ada yang ditinggalkan arguments.callee- referensi ke fungsi yang disebut. Yang kedua jika Anda memiliki referensi ke fungsi Anda, Anda dapat dengan mudah mendapatkan representasi tekstual mereka. Pada yang ketiga jika Anda memanggil fungsi Anda sebagai konstruktor Anda juga dapat memiliki tautan melalui yourObject.constructor. NB: Solusi pertama sudah usang jadi jika Anda tidak bisa tidak menggunakannya, Anda juga harus memikirkan arsitektur aplikasi Anda. Jika Anda tidak memerlukan nama variabel yang tepat, gunakan saja di dalam fungsi variabel internal argumentstanpa sihir apa pun.

https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/callee

Semuanya akan memanggil toString dan ganti dengan re agar kita dapat membuat helper:

// getting names of declared parameters
var getFunctionParams = function (func) {
    return String(func).replace(/[^\(]+\(([^\)]*)\).*/m, '$1');
}

Beberapa contoh:

// Solution 1. deprecated! don't use it!
var myPrivateFunction = function SomeFuncName (foo, bar, buz) {
    console.log(getFunctionParams(arguments.callee));
};
myPrivateFunction (1, 2);

// Solution 2.
var myFunction = function someFunc (foo, bar, buz) {
    // some code
};
var params = getFunctionParams(myFunction);
console.log(params);

// Solution 3.
var cls = function SuperKewlClass (foo, bar, buz) {
    // some code
};
var inst = new cls();
var params = getFunctionParams(inst.constructor);
console.log(params);

Nikmati dengan JS!

UPD: Jack Allan diberikan solusi yang sedikit lebih baik sebenarnya. GJ Jack!

Apa pun solusinya, itu tidak boleh rusak pada fungsi aneh, yang toString()tampak sama anehnya:

function  (  A,  b
,c      ,d
){}

Juga, mengapa menggunakan ekspresi reguler yang kompleks? Ini bisa dilakukan seperti:

function getArguments(f) {
    return f.toString().split(')',1)[0].replace(/\s/g,'').substr(9).split(',');
}

Ini bekerja di mana-mana dengan setiap fungsi, dan satu-satunya regex adalah penghapusan spasi putih yang bahkan tidak memproses seluruh string karena .splittriknya.

Ok jadi pertanyaan lama dengan banyak jawaban yang memadai. di sini adalah penawaran saya yang tidak menggunakan regex, kecuali untuk tugas kasar stripping spasi putih. (Saya harus mencatat bahwa fungsi "strips_comments" sebenarnya menghapusnya, daripada menghapusnya secara fisik. Itu karena saya menggunakannya di tempat lain dan karena berbagai alasan memerlukan lokasi token non komentar asli untuk tetap utuh)

Ini adalah blok kode yang cukup panjang karena pasta ini termasuk kerangka uji mini.

    function do_tests(func) {

    if (typeof func !== 'function') return true;
    switch (typeof func.tests) {
        case 'undefined' : return true;
        case 'object'    : 
            for (var k in func.tests) {

                var test = func.tests[k];
                if (typeof test==='function') {
                    var result = test(func);
                    if (result===false) {
                        console.log(test.name,'for',func.name,'failed');
                        return false;
                    }
                }

            }
            return true;
        case 'function'  : 
            return func.tests(func);
    }
    return true;
} 
function strip_comments(src) {

    var spaces=(s)=>{
        switch (s) {
            case 0 : return '';
            case 1 : return ' ';
            case 2 : return '  ';
        default : 
            return Array(s+1).join(' ');
        }
    };

    var c1 = src.indexOf ('/*'),
        c2 = src.indexOf ('//'),
        eol;

    var out = "";

    var killc2 = () => {
                out += src.substr(0,c2);
                eol =  src.indexOf('\n',c2);
                if (eol>=0) {
                    src = spaces(eol-c2)+'\n'+src.substr(eol+1);
                } else {
                    src = spaces(src.length-c2);
                    return true;
                }

             return false;
         };

    while ((c1>=0) || (c2>=0)) {
         if (c1>=0) {
             // c1 is a hit
             if ( (c1<c2) || (c2<0) )  {
                 // and it beats c2
                 out += src.substr(0,c1);
                 eol = src.indexOf('*/',c1+2);
                 if (eol>=0) {
                      src = spaces((eol-c1)+2)+src.substr(eol+2);
                 } else {
                      src = spaces(src.length-c1);
                      break;
                 }
             } else {

                 if (c2 >=0) {
                     // c2 is a hit and it beats c1
                     if (killc2()) break;
                 }
             }
         } else {
             if (c2>=0) {
                // c2 is a hit, c1 is a miss.
                if (killc2()) break;  
             } else {
                 // both c1 & c2 are a miss
                 break;
             }
         }

         c1 = src.indexOf ('/*');
         c2 = src.indexOf ('//');   
        }

    return out + src;
}

function function_args(fn) {
    var src = strip_comments(fn.toString());
    var names=src.split(')')[0].replace(/\s/g,'').split('(')[1].split(',');
    return names;
}

function_args.tests = [

     function test1 () {

            function/*al programmers will sometimes*/strip_comments_tester/* because some comments are annoying*/(
            /*see this---(((*/ src//)) it's an annoying comment does not help anyone understand if the 
            ,code,//really does
            /**/sucks ,much /*?*/)/*who would put "comment\" about a function like (this) { comment } here?*/{

            }


        var data = function_args(strip_comments_tester);

        return ( (data.length==4) &&
                 (data[0]=='src') &&
                 (data[1]=='code') &&
                 (data[2]=='sucks') &&
                 (data[3]=='much')  );

    }

];
do_tests(function_args);

Ini salah satu caranya:

// Utility function to extract arg name-value pairs
function getArgs(args) {
    var argsObj = {};

    var argList = /\(([^)]*)/.exec(args.callee)[1];
    var argCnt = 0;
    var tokens;
    var argRe = /\s*([^,]+)/g;

    while (tokens = argRe.exec(argList)) {
        argsObj[tokens[1]] = args[argCnt++];
    }

    return argsObj;
}

// Test subject
function add(number1, number2) {
    var args = getArgs(arguments);
    console.log(args); // ({ number1: 3, number2: 4 })
}

// Invoke test subject
add(3, 4);

Catatan: Ini hanya berfungsi pada browser yang mendukung arguments.callee.

Catatan: jika Anda ingin menggunakan destruksi parameter ES6 dengan solusi teratas tambahkan baris berikut.

if (result[0] === '{' && result[result.length - 1 === '}']) result = result.slice(1, -1)

parameter fungsi nilai string gambar secara dinamis dari JSON . Karena item.product_image2 adalah string URL, Anda harus memasukkannya ke dalam tanda kutip ketika Anda memanggil changeImage di dalam parameter.

My Function Onclick

items+='<img src='+item.product_image1+' id="saleDetailDivGetImg">';
items+="<img src="+item.product_image2+"  onclick='changeImage(\""+item.product_image2+"\");'>";

Fungsi saya

<script type="text/javascript">
function changeImage(img)
 {
    document.getElementById("saleDetailDivGetImg").src=img;
    alert(img);
}
</script>