فهم بسيط لهذا الإشارة في جافا سكريبت

بادئ ذي بدء ، يجب القول أنه لا يمكن تحديد هذا الإشارة عند تعريف الوظيفة. فقط عندما يتم تنفيذ الوظيفة ، يمكن لهذه النقطة إلى من هي هذه النقطة. في الواقع ، يشير هذا في النهاية إلى الكائن الذي يسميه (هناك بعض المشكلات في هذه الجملة ، وسنشرح سبب وجود مشاكل لاحقًا. على الرغم من أن معظم المقالات على الإنترنت تقول هذا ، على الرغم من أنه لن تكون هناك مشكلة في فهم ذلك في كثير من الحالات ، من غير الدقيق في الواقع فهمها ، لذلك ستشعر أنه لا يمكنك اكتشاف ذلك عند فهم ذلك). ثم سأناقش هذه القضية بعمق التالي.

لماذا تعلم هذا؟ إذا كنت قد تعلمت البرمجة الوظيفية والبرمجة الموجهة للكائنات ، فيجب أن تعرف ما يجب القيام به. إذا لم تكن قد تعلمت ذلك ، فلن تضطر إلى قراءة هذا المقال في الوقت الحالي. بالطبع ، إذا كنت مهتمًا ، فيمكنك أيضًا قراءتها. بعد كل شيء ، هذا شيء يجب إتقانه في JS.

مثال 1:

 الدالة A () {var user = "Little J" ؛ console.log (this.user) ؛ // undefined console.log (this) ؛ // window} a () ؛

وفقًا لما قلناه أعلاه ، يشير هذا في النهاية إلى الكائن الذي يطلق عليه. يتم الإشارة بالفعل إلى الوظيفة A هنا بواسطة كائن النافذة ، ويمكن أن يثبت الكود التالي ذلك.

 الدالة A () {var user = "Little J" ؛ console.log (this.user) ؛ // undefined console.log (this) ؛ } window.a () // window

تمامًا مثل الكود أعلاه ، فإن التنبيه هو في الواقع خاصية للنافذة ، كما أنه يشير إلى النافذة.

مثال 2:

 var o = {user: "Chasing Dreams" ، fn: function () {console.log (this.user) ؛ // مطاردة الأحلام}} o.fn () ؛

يشير هذا هنا إلى كائن o ، لأنك تسمي هذا fn وتنفيذها من خلال O.FN () ، وبالتالي فإن الإشارة الطبيعية هو كائن o. أود أن أؤكد مرة أخرى هنا أنه لا يمكن تحديد هذا الإشارة عند إنشاء الوظيفة ، ولا يمكن تحديدها إلا عندما يتم استدعاؤها. من يسميه سيشير إلى من ، يجب عليك معرفة ذلك.

في الواقع ، المثال 1 والمثال 2 ليسا دقيقين بما فيه الكفاية. المثال التالي يمكن أن يقلب النظرية أعلاه.

إذا كنت ترغب في فهم ذلك بدقة ، فيجب أن تنظر إلى الأمثلة القليلة التالية.

مثال 3:

 var o = {user: "catching dreams" ، fn: function () {console.log (this.user) ؛ // catching dreams}} window.o.fn () ؛

هذا الرمز هو نفس الرمز أعلاه ، ولكن لماذا هذه النقطة إلى النافذة؟ إذا اتبعت النظرية أعلاه ، فهذه النقطة إلى الكائن الذي يطلق عليه. دعني أقول شيئًا آخر هنا. Windows هو كائن عالمي في JS. المتغير الذي نقوم بإنشائه يضيف بالفعل سمات إلى النافذة ، حتى تتمكن من استخدام نافذة لتوجيه الكائن O هنا.

لن أشرح لماذا لا يشير هذا الرمز أعلاه إلى النافذة. دعونا نلقي نظرة على رمز آخر.

 var o = {a: 10 ، b: {a: 12 ، fn: function () {console.log (this.a) ؛ // 12}}} obfn () ؛

يشير هذا أيضًا إلى كائن O ، لكن هذا لا ينفذها ، لذلك ستقول بالتأكيد أن ما قلته في البداية هو كل شيء خاطئ؟ في الواقع ، ليس الأمر كذلك ، إنه لم يكن دقيقًا في البداية. بعد ذلك ، سأضيف جملة واحدة. أعتقد أنه يمكنك فهم المشكلة التي يشير إليها هذا بدقة.

========================================================================= >>>

الحالة 1 : إذا كان هناك هذا في وظيفة ، ولكن لا يطلق عليه كائن في المستوى السابق ، فإن هذا يشير إلى النافذة. ما يجب شرحه هنا هو أنه في الإصدار الصارم من JS ، هذا يشير إلى النافذة ، لكننا لن نناقش مشكلة الإصدار الصارم هنا. إذا كنت تريد أن تعرف ، يمكنك البحث عبر الإنترنت بنفسك.

========================================================================= >>>

الحالة 2 : إذا كان هناك هذا في وظيفة ويتم استدعاء هذه الوظيفة بواسطة كائن في المستوى السابق ، فإن هذا يشير إلى الكائن على المستوى السابق.

========================================================================= >>>

الحالة 3: إذا كان هناك هذا في وظيفة ، فإن هذه الوظيفة تحتوي على كائنات متعددة. على الرغم من أن هذه الوظيفة تسمى الكائن الخارجي ، فإن هذا يشير فقط إلى الكائن في المستوى التالي. مثال 3 يمكن أن يثبت أنه إذا كنت لا تصدق ذلك ، فلنستمر في النظر إلى بعض الأمثلة بعد ذلك.

 var o = {a: 10 ، b: {// a: 12 ، fn: function () {console.log (this.a) ؛ // undefined}}} obfn () ؛

على الرغم من عدم وجود سمة A في الكائن B ، فإن هذا يشير أيضًا إلى الكائن B ، لأن هذا سيشير فقط إلى كائنه السابق ، بغض النظر عما إذا كان هناك أي شيء يريده في هذا الكائن.

هناك حالة خاصة أخرى ، مثال 4:

 var o = {a: 10 ، b: {a: 12 ، fn: function () {console.log (this.a) ؛ // undefined console.log (this) ؛ // window}}} var j = obfn ؛ j () ؛

هذه النقاط إلى النافذة هنا ، أليس كذلك في حيرة من أمرها؟ في الواقع ، فذلك لأنك لا تفهم جملة ، وهو أمر بالغ الأهمية أيضًا.

يشير هذا دائمًا إلى الكائن الذي يطلق عليه أخيرًا ، مما يعني من يطلق عليه عند تنفيذه. في المثال 4 ، على الرغم من أنه يتم الرجوع إلى الوظيفة FN بواسطة الكائن B ، إلا أنه لا يتم تنفيذها عند تعيين FN للمتغير J ، لذلك يشير في النهاية إلى النافذة ، وهو ما يختلف عن المثال 3. مثال 3 ينفذ مباشرة FN.

هذا هو في الواقع ذلك ، لكن الإشارة ستكون مختلفة في ظل ظروف مختلفة. الملخص أعلاه هو خطأ بسيط في كل مكان ، ولا يمكن قول أنه خطأ ، لكن الموقف سيكون مختلفًا في بيئات مختلفة ، لذلك لا يمكنني شرحه بوضوح في وقت واحد ، حتى لا تتمكن إلا من تجربة ذلك ببطء.

إصدار المنشئ هذا:

 الدالة fn () {this.user = "small j" ؛} var a = new fn () ؛ console.log (a.user) ؛ // صغير ي

السبب في أن الكائن A يمكن أن يشير إلى المستخدم في الوظيفة FN هنا هو أن الكلمة الرئيسية الجديدة يمكنها تغيير اتجاه هذا وتوجيه هذا إلى الكائن A. لماذا أقول a هو كائن؟ لأن استخدام الكلمة الرئيسية الجديدة هو إنشاء مثيل كائن. فهم هذه الجملة ، يمكنك التفكير في مثالنا 3. نستخدم المتغير A لإنشاء مثيل FN (أي ما يعادل نسخ FN إلى كائن A). في هذا الوقت ، يتم إنشاؤه للتو وعدم تنفيذه. الدعوة إلى هذه الوظيفة FN هي الكائن A ، لذلك هذا هو الكائن الطبيعي أ. فلماذا يوجد مستخدم في كائن fn؟ نظرًا لأنك قمت بنسخ وظيفة FN في الكائن A ، واستخدام الكلمة الرئيسية الجديدة يعادل نسخ نسخة.

بالإضافة إلى ما سبق ، يمكننا أيضًا تغيير اتجاه هذا من قبل أنفسنا ========== >>> الاتصال ، تطبيق ، ربط

قم بتحديث مشكلة صغيرة عندما تعود هذه اللقاءات

 دالة fn () {this.user = 'small j' ؛ يعود {}؛ } var a = new fn ؛ console.log (A.user) ؛ // غير محدد

انظر إلى واحد آخر

 دالة fn () {this.user = 'small j' ؛ Return Function () {} ؛} var a = new fn ؛ console.log (A.user) ؛ // غير محدد

تعال مرة أخرى

 دالة fn () {this.user = 'small j' ؛ إرجاع 1 ؛} var a = new fn ؛ console.log (A.user) ؛ // small jfunction fn () {this.user = 'small j' ؛ إرجاع غير محدد ؛} var a = new fn ؛ console.log (A.user) ؛ // صغير ي

إذا كانت قيمة الإرجاع كائنًا ، فإن هذا يشير إلى الكائن الذي تم إرجاعه. إذا لم تكن قيمة الإرجاع كائنًا ، فلا يزال هذا يشير إلى مثيل للوظيفة.

 دالة fn () {this.user = 'small j' ؛ إرجاع غير محدد ؛} var a = new fn ؛ console.log (a) ؛ // fn {user: "small j"}

نقطة أخرى هي أنه على الرغم من أن NULL هو أيضًا كائن ، إلا أن هذا لا يزال يشير إلى مثيل لهذه الوظيفة هنا ، لأن NULL أكثر خصوصية.

 دالة fn () {this.user = 'small j' ؛ إرجاع null ؛} var a = new fn ؛ console.log (A.user) ؛ // صغير ي

مكملات نقاط المعرفة:

1. الافتراضي هذا في الإصدار الصارم لم يعد نافذة ، ولكن غير محدد.

2. سيغير المشغل الجديد مشكلة الإشارة إلى الوظيفة. على الرغم من أننا شرحنا ذلك أعلاه ، إلا أننا لم نناقش هذه القضية بعمق. نادراً ما يتم ذكره على الإنترنت ، لذلك من الضروري التحدث عنه هنا.

 الدالة fn () {this.num = 1 ؛} var a = new fn () ؛ console.log (a.num) ؛ // 1

لماذا هذه النقطة إلى؟ أولاً ، ستقوم الكلمة الرئيسية الجديدة بإنشاء كائن فارغ ، ثم سيتم استدعاء طريقة تطبيق الوظيفة تلقائيًا لتوجيه ذلك إلى هذا الكائن الفارغ. وبهذه الطريقة ، سيتم استبدال هذا داخل الوظيفة بهذا الكائن الفارغ.

ما سبق هو كل محتوى هذه المقالة. آمل أن يكون ذلك مفيدًا لتعلم الجميع وآمل أن يدعم الجميع wulin.com أكثر.