Обратитесь к функции JavaScript внутри себя

Как rfw сказал, Это самый прямой путь, если функция имеет одно имя:

var crazy = function() {
    console.log(crazy);
    console.log(crazy.isCrazy);
};

crazy.isCrazy = 'totally';
crazy();

в случае, если он может иметь разные имена, или вы хотели передать его вокруг, он должен быть завернут в закрытие:

var crazy = (function(){
    var that = function() {
        console.log(that);
        console.log(that.isCrazy);
    };
    return that;
})();

crazy.isCrazy = 'totally';
crazy();

вы должны дать ему свое имя, так что:

var crazy = function() {
    console.log(crazy);
    console.log(crazy.isCrazy);
}
crazy.isCrazy = 'totally';
crazy();

переменная this применяется только в области объекта, например, если вы вызвали свою версию

это должно иметь дело с областью действия функции crazy. Если можно передать любую область в функцию с помощью функции call().

вместо

crazy();

использовать

crazy.call(crazy);

подробнее refer
http://odetocode.com/blogs/scott/archive/2007/07/05/function-apply-and-function-call-in-javascript.aspx
https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/Call
http://devlicio.us/blogs/sergio_pereira/archive/2009/02/09/javascript-5-ways-to-call-a-function.aspx

привязать функцию к себе (взяв подсказку из ответов @ArunPJohny и @BudgieInWA):

crazy = crazy.bind(crazy);

это даст вам доступ из функции к его свойствам через this.

> crazy()
function () {
    console.log(this);
    console.log(this.isCrazy); // works now
}

это кажется лучшим решением, чем принятый ответ, который использует callee функция, которая устарела и не работает в строгом режиме.

теперь вы также можете рекурсивно вызвать саму функцию с помощью this() ты так склонный.

мы будем называть это self-thisifying. Напишите немного полезной функции:

function selfthisify(fn) { return fn.bind(fn); }
crazy = selfthisify(crazy);
crazy();

или, если вы предпочитаете более "семантические" имена, вы можете назвать его accessOwnProps.

если вы синтаксический тип сахара человека, вы можете добавить selfthisify свойство прототипа функции:

Object.defineProperty(Function.prototype, 'selfthisify', {
    get: function() { return this.bind(this); }
});

теперь вы можете сказать

crazy.selfthisify();

можно использовать call метод

var crazy = function() {
    console.log(this);
    console.log(this.isCrazy);
}
crazy.isCrazy = 'totally';
crazy.call(crazy);
// calls crazy using crazy as the target, instead of window:
// functionToCall.call(objectToUseForThis);

хотя если ваша функция только одно имя, вы можете сделать это:

var crazy = function() {
    console.log(crazy);
    console.log(crazy.isCrazy);
}
crazy.isCrazy = 'totally';
crazy();

как я могу получить функцию, чтобы обратиться к сам по себе?

идея "себя" не существует с функциями. То, что вам нужно-это объект, а не просто функция. Объект есть знание о себе через слово "это". Внутри функции 'this' указывает на глобальный объект-в данном случае на объект window. Но если вы используете свою функцию в качестве функции конструктора для создания объекта (используя новая оператор), то объект 'этот' указатель будет указывать на сам объект.

Я.е этой указывает на объект, если вы пишете:

var anObject = new crazy();

таким образом, вы можете переписать свой код следующим образом:

var crazy = function() {
    this.printMe = function(){
        console.log(this);
        console.log(this.isCrazy); 
    }
}

var anObject = new crazy(); //create an object
anObject.isCrazy = 'totally'; //add a new property to the object
anObject.printMe(); //now print

в случае, если вы хотите, чтобы добавить свойство до объект создается, затем вы должны добавить свойство к функции прототип следующим образом:

var crazy = function() {
    console.log(this);
    console.log(this.isCrazy); 
}

crazy.prototype.isCrazy = 'totally'; //add the property to the function's prototype
var anObject = new crazy(); //invoke the constructor

подробнее о мой блог для детального объяснения этих понятия с образцами кода.

самый простой способ сделать саму функцию доступной в своем теле-это сделать var crazy = function crazy2() { crazy2(); }, Это нормально для crazy и crazy2 иметь одно и то же имя, так как первое вхождение-это имя во внешней области, а второе-имя в теле функции.

или просто function crazy() { crazy(); } который будет определять crazy в обеих областях.

вы действительно пытаетесь создать объект 'class'?

function crazy(crazyState) {
   this.isCrazy = crazyState;
   console.log(this);
   console.log(this.isCrazy);
}
crazy.prototype.alertMe = function() { alert('I am '+ this.isCrazy +' crazy.'); }

var crazyObj = new crazy('totally');
crazyObj.alertMe();

crazyObj.isCrazy = 'not';
crazyObj.alertMe();

забавно, что ты спрашиваешь, приятель. Я только что прошел этот же вопрос для разных целей. Быстрая версия окончательного кода:

$a = function() {};

$ = function() {
    if (!(this instanceof $)) {
        return new $();
    }

    this.name = "levi";

    return this;
};

//helper function
var log = function(message) {
    document.write((message ? message : '') + "<br/>");
};

log("$().name == window.name: " + ($().name == window.name)); //false
log("$().name: " + $().name); //levi
log("window.name: " + window.name); //result

log();

log("$a instanceof $: " + ($a instanceof $)); //false
log("typeof $a: " + (typeof $a)); //function
log("typeof $: " + (typeof $)); //function

критический фрагмент:

    if (!(this instanceof $)) {
        return new $();
    }

если this не указывает на объект правильного типа, то он делает new один, который будет правильно scope this. Остальная часть кода просто существует для проверки того, что он действительно работает по назначению.

для того, чтобы Вы код для работы следуйте ниже

        function crazy_object (crazy) {
          this.isCrazy = crazy
        }
        
        var create_crazy = new crazy_object('hello') //creating object
        
        console.log(create_crazy); //=> { isCrazy = 'hello' }
        
        var crazy = function() {
            console.log(this); //=> { isCrazy = 'totally' }
            console.log(this.isCrazy); //=> 'totally'
        }
        
        create_crazy.isCrazy = 'totally'; //=> isCrazy = 'totally'
        //below we pass the created object in function crazy.
        //And doing that we can use the keywork `this` and refer to the object
        crazy.call(create_crazy, null);

С помощью вызов и применить метод, который мы можем передать в функцию a свойство, и в этой функции мы можем использовать свойство с ключевым словом this

например:

function speak (message) {
  console.log(`A person with name ${this.name} say ${message}`);
}

speak.call({ name: 'Roland' }, 'Javascript is awesome');

чтобы использовать его со свойством:

function speak (message) {
  console.log(`A person with name ${this.name} say ${message}`);
}

var name = 'Roland'

speak.call({ name }, 'Javascript is awesome');