CoffeeScript 2



coffeescript

CoffeeScript

CoffeeScript هي لغة صغيرة تتحول إلى JavaScript. تحت ذلك الصحن الجاف المزعج ، جافا سكريبت لديه دائما قلب رائع. تعتبر CoffeeScript محاولة لفضح الأجزاء الجيدة من JavaScript بطريقة بسيطة.

القاعدة الذهبية لـ CoffeeScript هي: "إنها مجرد JavaScript." رمز يجمع واحد إلى واحد في JS يعادل ، وليس هناك تفسير في وقت التشغيل. يمكنك استخدام أي مكتبة جافا سكريبت موجودة بسلاسة من CoffeeScript (والعكس بالعكس). يكون الناتج المترجم قابلاً للقراءة ، ويتم طباعته بشكل جيد ، ويميل إلى التشغيل بسرعة أو أسرع من جافا سكريبت بخط اليد المكافئ.

أحدث نسخة: 2.2.2

# Install locally for a project:
npm install --save-dev coffeescript

# Install globally to execute .coffee files anywhere:
npm install --global coffeescript

نظرة عامة

CoffeeScript على أعلى اليسار ، جمعت ناتج جافا سكريبت في أسفل اليمين . إن CoffeeScript قابل للتعديل!

# Assignment:
number   = 42
opposite = true

# Conditions:
number = -42 if opposite

# Functions:
square = (x) -> x * x

# Arrays:
list = [1, 2, 3, 4, 5]

# Objects:
math =
  root:   Math.sqrt
  square: square
  cube:   (x) -> x * square x

# Splats:
race = (winner, runners...) ->
  print winner, runners

# Existence:
alert "I knew it!" if elvis?

# Array comprehensions:
cubes = (math.cube num for num in list)
// Assignment:
var cubes, list, math, num, number, opposite, race, square;

number = 42;

opposite = true;

if (opposite) {
  // Conditions:
  number = -42;
}

// Functions:
square = function(x) {
  return x * x;
};

// Arrays:
list = [1, 2, 3, 4, 5];

// Objects:
math = {
  root: Math.sqrt,
  square: square,
  cube: function(x) {
    return x * square(x);
  }
};

// Splats:
race = function(winner, ...runners) {
  return print(winner, runners);
};

if (typeof elvis !== "undefined" && elvis !== null) {
  // Existence:
  alert("I knew it!");
}

// Array comprehensions:
cubes = (function() {
  var i, len, results;
  results = [];
  for (i = 0, len = list.length; i < len; i++) {
    num = list[i];
    results.push(math.cube(num));
  }
  return results;
})();

كوفي رسك 2

ما هو الجديد في CoffeeScript 2؟

أكبر تغيير في CoffeeScript 2 هو أن مترجم CoffeeScript الآن ينتج قواعد JavaScript الحديثة (ES6 أو ES2015 والإصدارات الأحدث). A CoffeeScript => يصبح JS => ، تصبح class CoffeeScript class JS وهكذا. تتضمن الميزات الجديدة الرئيسية في CoffeeScript 2 وظائف async و JSX . يمكنك قراءة المزيد في announcement .

هناك عدد قليل جدًا من التغييرات العاجلة من الإصدار 1.x من CoffeeScript . نأمل أن تكون عملية الترقية سهلة بالنسبة لمعظم المشاريع.

التوافق

وباستثناء modules (عبارات import export ) و JSX ، فإن جميع ميزات JavaScript الحديثة التي يدعمها CoffeeScript يمكن تشغيلها أصلاً في Node 7.6+ ، مما يعني أن العقدة يمكنها تشغيل إخراج CoffeeScript دون أي معالجة إضافية مطلوبة. يمكنك تشغيل الاختبارات في متصفحك لمعرفة ما إذا كان متصفحك يمكنه أن يفعل نفس الشيء. أما بالنسبة للمتصفحات القديمة أو الإصدارات الأقدم من العقدة ، فإن عملية transpilation مطلوبة.

يعد دعم بنية جافا سكريبت الحديثة أمرًا مهمًا لضمان التوافق مع الأطر التي تفترض الميزات الحديثة. الآن بعد أن قامت CoffeeScript بجمع الفئات إلى الكلمة الأساسية class ، من الممكن extend فئة JavaScript ؛ لم يكن ذلك ممكنًا في CoffeeScript 1. إن التكافؤ في كيفية عمل ميزات اللغة مهم أيضًا من تلقاء نفسه ؛ إن "CoffeeScript" هو مجرد جافا سكريبت ، ولذلك يجب أن تتصرف الأشياء مثل قيم المعلمات الافتراضية الافتراضية على أنها موجودة في CoffeeScript كما في JavaScript. تتصرف بعض هذه الميزات بطريقة مختلفة قليلاً في JavaScript عما كانت عليه في CoffeeScript 1 ؛ في مثل هذه الحالات ، نتفق مع مواصفات جافا سكريبت ، وقد وثقنا الاختلافات على أنها كسر التغييرات .

التركيب

يتوفر إصدار سطر الأوامر من coffee كأداة مساعدة Node.js ، مما يتطلب عقدة 6 أو أحدث. ومع ذلك ، لا يعتمد المحول البرمجي الأساسي على عقدة ، ويمكن تشغيله في أي بيئة جافا سكريبت ، أو في المتصفح (انظر Try CoffeeScript ).

للتثبيت ، تأكد أولاً من وجود نسخة عمل من أحدث إصدار مستقر من Node.js يمكنك بعد ذلك تثبيت CoffeeScript على مستوى العالم باستخدام npm :

npm install --global coffeescript

سيؤدي هذا إلى إتاحة أوامر coffee cake مستوى العالم.

إذا كنت تستخدم CoffeeScript في مشروع ، يجب عليك تثبيته محليًا لهذا المشروع حتى يتم تتبع إصدار CoffeeScript كواحد من تبعيات مشروعك. ضمن مجلد هذا المشروع:

npm install --save-dev coffeescript

ستبدو أوامر coffee cake أولاً في المجلد الحالي لمعرفة ما إذا تم تثبيت CoffeeScript محليًا ، واستخدام هذا الإصدار إذا كان الأمر كذلك. يسمح ذلك بتثبيت إصدارات مختلفة من CoffeeScript عالمياً ومحلياً.

إذا كنت تخطط لاستخدام خيار --transpile (انظر transpilation ) ، فستحتاج أيضًا إلى تثبيت برنامج babel-core إما عالميًا أو محليًا ، اعتمادًا على ما إذا كنت تستخدم إصدارًا من برنامج CoffeeScript تم تثبيته عالميًا أو محليًا.

استعمال

سطر الأوامر

بمجرد التثبيت ، يجب أن يكون لديك إمكانية الوصول إلى أمر coffee ، الذي يمكنه تنفيذ النصوص البرمجية ، وتجميع ملفات .coffee إلى .js ، وتوفير REPL تفاعلي. يأخذ أمر coffee الخيارات التالية:

اختيار وصف
-c, --compile ترجمة برنامج نصي .coffee إلى ملف جافا سكريبت .js . يحمل نفس الاسم.
-t, --transpile قم بتوصيل ناتج المجمع الخاص بـ CoffeeScript من خلال Babel قبل حفظ JavaScript الذي تم إنشاؤه أو تشغيله. يتطلب babel-core ، وخيارات الانتقال إلى Babel في ملف .babelrc أو package.json باستخدام مفتاح babel في مسار الملف أو المجلد المطلوب تجميعه. انظر transpilation .
-m, --map قم بتوليد خرائط المصدر جنبا إلى جنب مع ملفات جافا سكريبت المترجمة. يضيف توجيهات sourceMappingURL إلى جافا سكريبت أيضًا.
-M, --inline-map تمامًا مثل - --map ، ولكنها تتضمن خريطة المصدر مباشرةً في ملفات جافا سكريبت المجمعة ، بدلاً من تضمينها في ملف منفصل.
-i, --interactive ابدأ جلسة تفاعلية لـ CoffeeScript لتجربة قصاصات قصيرة. مطابق لاستدعاء coffee بدون أي حجج.
-o, --output [DIR] اكتب جميع ملفات جافا سكريبت المجمعة في الدليل المحدد. استخدام جنبا إلى جنب مع - --compile أو - --watch .
-w, --watch مشاهدة الملفات للتغييرات ، وإعادة تشغيل الأمر المحدد عند تحديث أي ملف.
-p, --print بدلاً من كتابة JavaScript كملف ، اطبعه مباشرةً إلى stdout .
-s, --stdio الأنابيب في CoffeeScript إلى STDIN واستعادة JavaScript عبر STDOUT. جيد للاستخدام مع العمليات المكتوبة بلغات أخرى. مثال:
cat src/cake.coffee | coffee -sc
-l, --literate يوزع الرمز كـ Literate CoffeeScript. تحتاج فقط إلى تحديد هذا عند تمرير التعليمات البرمجية مباشرة على stdio ، أو استخدام نوع من اسم ملف ملحق أقل.
-e, --eval ترجمة وطباعة مقتطف صغير من CoffeeScript مباشرة من سطر الأوامر. فمثلا:
coffee -e "console.log num for num in [10..1]"
-r, --require [MODULE] require() الوحدة المعطاة قبل البدء في REPL أو تقييم الكود المعطى --eval .
-b, --bare قم بتجميع JavaScript بدون التفاف الأمان الخاص بالمستوى الأعلى .
--no-header قم بإيقاف رأس "Generated by CoffeeScript".
--nodejs تحتوي node التنفيذية على بعض الخيارات المفيدة التي يمكنك تعيينها ، مثل --debug ، --debug-brk ، --max-stack-size ، و --expose-gc . استخدم هذه العلامة لإعادة توجيه الخيارات مباشرة إلى Node.js. لتمرير علامات متعددة ، استخدم - --nodejs عدة مرات.
--tokens بدلا من تحليل CoffeeScript ، فقط lex ، وطباعة دفق الرمز المميز. تستخدم لتصحيح أخطاء المحول البرمجي.
-n, --nodes بدلاً من تجميع الـ CoffeeScript ، قم فقط بقراءة وتحليلها ، وطباعة شجرة التحليل. تستخدم لتصحيح أخطاء المحول البرمجي.

أمثلة:

  • ترجمة شجرة دليل ملفات .coffee في src إلى شجرة متوازي ملفات .js في lib :
    coffee --compile --output lib/ src/
  • شاهد ملفًا للتغييرات وأعد تجميعها في كل مرة يتم فيها حفظ الملف:
    coffee --watch --compile experimental.coffee
  • سلسل قائمة الملفات في برنامج نصي واحد:
    coffee --join project.js --compile src/*.coffee
  • اطبع JS المحولة من سطر واحد:
    coffee -bpe "alert i for i in [0..10]"
  • جميعًا معًا ، راقب وأعيد تجميع مشروع بأكمله أثناء العمل عليه:
    coffee -o lib/ -cw src/
  • ابدأ في ملف PDF الخاص بـ REPL ( Ctrl-D للخروج ، Ctrl-V للخطوط المتعددة):
    coffee

لاستخدام --transpile ، راجع transpilation .

نود.جي إس

إذا كنت ترغب في استخدام CommonJS Node.js require ملفات من نوع CoffeeScript ، على سبيل المثال require './app.coffee' ، فيجب أولاً "تسجيل" CoffeeScript كملحق:

require 'coffeescript/register'

App = require './app' # The .coffee extension is optional

إذا كنت تريد استخدام واجهة برمجة تطبيقات المترجم ، على سبيل المثال لإنشاء تطبيق يقوم بترجمة سلاسل من CoffeeScript على الطاير ، فيمكنك require الوحدة النمطية الكاملة:

CoffeeScript = require 'coffeescript'

eval CoffeeScript.compile 'console.log "Mmmmm, I could really go for some #{Math.pi}"'

يحتوي أسلوب compile على compile(code, options) التواقيع compile(code, options) حيث تكون code عبارة عن سلسلة من كود برنامج CoffeeScript ، options الاختيارية هي كائن له بعض أو كل الخصائص التالية:

  • options.sourceMap ، boolean: إذا كانت true ، سيتم إنشاء خريطة مصدر ؛ بدلاً من إرجاع سلسلة ، ستقوم compile بإرجاع كائن من النموذج {js, v3SourceMap, sourceMap} .
  • options.inlineMap ، منطقي: إذا كانت true ، قم بإخراج خريطة المصدر كسلسلة مشفرة بقاعدة base64 في تعليق في الأسفل.
  • options.filename ، string: اسم الملف المراد استخدامه للخريطة المصدر. يمكن أن تتضمن مسارًا (نسبيًا أو مطلقًا).
  • options.bare ، منطقي: إذا كان صحيحا ، خرج دون التفاف السلامة وظيفة المستوى الأعلى .
  • options.header ، منطقي: إذا كان صحيحًا ، Generated by CoffeeScript رأس Generated by CoffeeScript .
  • options.transpile ، الكائن : في حالة التعيين ، يجب أن يكون هذا كائنًا به خيارات لتمريره إلى Babel . انظر transpilation .

Transpilation

يولِّد CoffeeScript 2 جافا سكريبت التي تستخدم أحدث بنية حديثة. قد لا يدعم وقت التشغيل أو المتصفحات التي تريد تشغيل شفرتك بها كل ذلك النحو . في هذه الحالة ، نريد تحويل جافا سكريبت الحديثة إلى جافا سكريبت أقدم والتي ستعمل في الإصدارات الأقدم من العقدة أو المتصفحات القديمة ؛ على سبيل المثال ، { a } = obj into a = obj.a يتم ذلك عن طريق المتسللين مثل Babel ، Bublé أو Traceur Compiler .

بداية سريعة

من جذر مشروعك:

npm install --save-dev babel-core babel-preset-env
echo '{ "presets": ["env"] }' > .babelrc
coffee --compile --transpile --inline-map some-file.coffee

الترميز مع مترجم CoffeeScript

لجعل الأمور سهلة ، يحتوي برنامج CoffeeScript على دعم مدمج لبرنامج Transpiler الشهير في Babel . يمكنك استخدامه عبر خيار سطر الأوامر --transpile أو خيار API Node transpile . لاستخدام إما ، يجب تثبيت babel-core في مشروعك:

npm install --save-dev babel-core

أو إذا كنت تقوم بتشغيل أمر coffee خارج مجلد المشروع ، باستخدام وحدة coffeescript مثبتة عالميًا ، coffeescript تثبيت babel-core عالميًا:

npm install --global babel-core

بشكل افتراضي ، لا تفعل بابل أي شيء - فهي لا تضع افتراضات حول ما تريد أن تصل إليه. تحتاج إلى تزويده بتهيئة بحيث يعرف ما يجب القيام به. إحدى الطرق للقيام بذلك هي عن طريق إنشاء ملف .babelrc في المجلد الذي يحتوي على الملفات التي تقوم .babelrc ، أو في أي مجلد أصل فوق المسار فوق تلك الملفات. (يدعم Babel طرقًا أخرى أيضًا). سيكون الحد الأدنى من ملف .babelrc مجرد { "presets": ["env"] } . هذا يعني أنك قمت بتركيب babel-preset-env :

npm install --save-dev babel-preset-env  # Or --global for non-project-based usage

شاهد موقع بابل على الإنترنت للتعرف على الإعدادات المسبقة والمكونات الإضافية والعديد من الخيارات المتاحة أمامك. آخر الإعداد المسبق الذي قد تحتاج إليه هو transform-react-jsx إذا كنت تستخدم transform-react-jsx (يمكن استخدام transform-react-jsx أيضًا مع إطارات أخرى).

بمجرد أن يتم babel-core و babel-preset-env (أو أي إعدادات مسبقة أو ملحقات أخرى) ، وملف .babelrc (أو ما يماثلها) في المكان ، يمكنك استخدام coffee --transpile إلى إخراج منتج CoffeeScript من خلال Babel باستخدام الخيارات لقد قمت بحفظ

إذا كنت تستخدم CoffeeScript عبر واجهة برمجة التطبيقات Node ، حيث يمكنك استدعاء CoffeeScript.compile بسلسلة ليتم تجميعها وكائن options ، transpile أن transpile مفتاح transpile لكائن options هو خيارات Babel:

CoffeeScript.compile(code, {transpile: {presets: ['env']}})

يمكنك أيضًا تحويل ناتج CoffeeScript دون استخدام خيار transpile ، على سبيل المثال كجزء من سلسلة transpile . يتيح لك ذلك استخدام برامج التحويل من غير Babel ، كما يمنحك تحكمًا أكبر في العملية. يوجد العديد من المتسابقين Webpack إعداد سلاسل إنشاء JavaScript ، مثل Webpack و Webpack و Grunt و Broccoli .

Polyfills

لاحظ أن الترميز لا يوفر تلقائيًا مدونات متعددة لرمزك. ستقوم CoffeeScript نفسها بإخراج Array.indexOf إذا كنت تستخدم عامل التشغيل أو بنية التدمير أو الانتشار / Array.indexOf ؛ و Function.bind إذا كنت تستخدم أسلوب منضم ( => ) في فئة. كلاهما مدعومان في Internet Explorer 9+ وكل المستعرضات الحديثة ، ولكنك ستحتاج إلى توفير polyfills إذا كنت تحتاج إلى دعم Internet Explorer 8 أو أدناه وتستخدم ميزات قد تؤدي إلى إخراج هذه الأساليب. ستحتاج أيضًا إلى توفير polyfills إذا كان الرمز الخاص بك يستخدم هذه الطرق أو طريقة أخرى مضافة في الإصدارات الحديثة من JavaScript. خيار polyfill واحد هو babel-polyfill ، على الرغم من وجود العديد other strategies other .

لغة الإشارة

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

يمكن تشغيل العديد من الأمثلة (حيث يكون من المنطقي) عن طريق الضغط على زر on على اليمين. يمكن تحرير CoffeeScript على اليسار ، وسيتم تحديث JavaScript أثناء تحريره.

أولاً ، الأساسيات: تستخدم CoffeeScript مسافات بيضاء كبيرة لتحديد كتل التعليمات البرمجية. لست بحاجة إلى استخدام الفواصل المنقوطة ; لإنهاء التعبيرات ، فإن إنهاء السطر سيؤدي فقط (على الرغم من أنه يمكن استخدام الفواصل المنقوطة لتلائم التعبيرات المتعددة في سطر واحد). بدلاً من استخدام الأقواس المتعرجة { } لإحاطة كتل التعليمات البرمجية في functions ، if-statements ، switch ، ومحاولة / catch ، استخدم المسافة البادئة.

لا تحتاج إلى استخدام الأقواس لاستدعاء وظيفة إذا كنت تمر الحجج. يتم التفاف المكالمة الضمنية إلى نهاية السطر أو التعبير الجبري.
console.log sys.inspect objectconsole.log(sys.inspect(object));

المهام

يتم تعريف الدوال من خلال قائمة اختيارية للمعلمات بين الأقواس والسهم وجسم الوظيفة. تبدو الوظيفة الفارغة كالتالي: ->

square = (x) -> x * x
cube   = (x) -> square(x) * x
var cube, square;

square = function(x) {
  return x * x;
};

cube = function(x) {
  return square(x) * x;
};

قد يكون للوظائف أيضًا قيم افتراضية للوسائط ، والتي سيتم استخدامها إذا كانت الوسيطة الواردة مفقودة ( undefined ).

fill = (container, liquid = "coffee") ->
  "Filling the #{container} with #{liquid}..."
var fill;

fill = function(container, liquid = "coffee") {
  return `Filling the ${container} with ${liquid}...`;
};

سلاسل

مثل جافا سكريبت والعديد من اللغات الأخرى ، يدعم موقع CoffeeScript السلاسل التي يتم تحديدها بواسطة الأحرف " أو ' . كما يدعم تطبيق CoffeeScript أيضًا الإقحام الداخلي داخل السلاسل " المقتبسة " باستخدام #{ … } . السلاسل المقتبسة الوحيدة هي حرفية. يمكنك حتى استخدام الاستيفاء في مفاتيح الكائن.

author = "Wittgenstein"
quote  = "A picture is a fact. -- #{ author }"

sentence = "#{ 22 / 7 } is a decent approximation of π"
var author, quote, sentence;

author = "Wittgenstein";

quote = `A picture is a fact. -- ${author}`;

sentence = `${22 / 7} is a decent approximation of π`;

سلاسل متعددة الخطوط مسموح بها في CoffeeScript. يتم ضم خطوط بمسافة مفردة ما لم ينتهي بخط مائل عكسي. يتم تجاهل المسافة البادئة.

mobyDick = "Call me Ishmael. Some years ago --
  never mind how long precisely -- having little
  or no money in my purse, and nothing particular
  to interest me on shore, I thought I would sail
  about a little and see the watery part of the
  world..."
var mobyDick;

mobyDick = "Call me Ishmael. Some years ago -- never mind how long precisely -- having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world...";

يمكن استخدام سلاسل القطع ، المحددة بـ """ أو ''' ، للاحتفاظ بنص منسق أو حساس للمسافة البادئة (أو إذا كنت لا ترغب في الهروب من علامات الاقتباس والفواصل العليا). يتم الحفاظ على مستوى المسافة البادئة الذي يبدأ الحظر طوال الوقت ، حتى يمكنك الاحتفاظ بكل ذلك بمحاذاة جسم الشفرة.

html = """
       <strong>
         cup of coffeescript
       </strong>
       """
var html;

html = "<strong>\n  cup of coffeescript\n</strong>";

سلاسل النصوص المقتبسة المزدوجة ، مثل سلاسل النصوص المزدوجة الأخرى ، تسمح بالاستيفاء.

الأشياء والصفائف

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

song = ["do", "re", "mi", "fa", "so"]

singers = {Jagger: "Rock", Elvis: "Roll"}

bitlist = [
  1, 0, 1
  0, 0, 1
  1, 1, 0
]

kids =
  brother:
    name: "Max"
    age:  11
  sister:
    name: "Ida"
    age:  9
var bitlist, kids, singers, song;

song = ["do", "re", "mi", "fa", "so"];

singers = {
  Jagger: "Rock",
  Elvis: "Roll"
};

bitlist = [1, 0, 1, 0, 0, 1, 1, 1, 0];

kids = {
  brother: {
    name: "Max",
    age: 11
  },
  sister: {
    name: "Ida",
    age: 9
  }
};

يحتوي موقع CoffeeScript على اختصار لإنشاء الكائنات عندما تريد تعيين المفتاح بمتغير يحمل نفس الاسم.

name = "Michelangelo"
mask = "orange"
weapon = "nunchuks"
turtle = {name, mask, weapon}
output = "#{turtle.name} wears an #{turtle.mask} mask. Watch out for his #{turtle.weapon}!"
var mask, name, output, turtle, weapon;

name = "Michelangelo";

mask = "orange";

weapon = "nunchuks";

turtle = {name, mask, weapon};

output = `${turtle.name} wears an ${turtle.mask} mask. Watch out for his ${turtle.weapon}!`;

تعليقات

في CoffeeScript ، تشير التعليقات إلى # character إلى نهاية السطر ، أو من ### إلى المظهر التالي لـ ### . يتم تجاهل التعليقات بواسطة المحول البرمجي ، على الرغم من أن المحول البرمجي يبذل قصارى جهده لإعادة إدخال التعليقات في جافا سكريبت الإخراج بعد التحويل البرمجي.

###
Fortune Cookie Reader v1.0
Released under the MIT License
###

sayFortune = (fortune) ->
  console.log fortune # in bed!
/*
Fortune Cookie Reader v1.0
Released under the MIT License
*/
var sayFortune;

sayFortune = function(fortune) {
  return console.log(fortune); // in bed!
};

مضمنة ### التعليقات تجعل التعليقات التوضيحية من النوع ممكنًا.

الكشف المعجل والسلامة المتغيرة

يتولى مترجم CoffeeScript العناية للتأكد من أن جميع المتغيرات الخاصة بك يتم الإعلان عنها بشكل صحيح ضمن نطاق معجم - لن تحتاج أبدًا إلى كتابة var بنفسك.

outer = 1
changeNumbers = ->
  inner = -1
  outer = 10
inner = changeNumbers()
var changeNumbers, inner, outer;

outer = 1;

changeNumbers = function() {
  var inner;
  inner = -1;
  return outer = 10;
};

inner = changeNumbers();

لاحظ كيف تم دفع كافة تعريفات المتغير إلى أعلى النطاق الأقرب ، في المرة الأولى التي تظهر فيها. outer لا يتم الإعلان عنه داخل الوظيفة الداخلية ، لأنه بالفعل في النطاق ؛ من ناحية أخرى ، لا ينبغي أن يكون داخل الوظيفة ، من ناحية أخرى ، القدرة على تغيير قيمة المتغير الخارجي الذي يحمل نفس الاسم ، وبالتالي يكون له إعلان خاص به.

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

على الرغم من منعها داخل هذه الوثائق من أجل الوضوح ، يتم التفاف كل مخرجات برنامج CoffeeScript (ما عدا في ملفات مع بيانات import أو export ) في وظيفة مجهولة: (function(){ … })(); . يجعل غلاف الأمان هذا ، مع التوليد التلقائي للكلمة الرئيسية var ، من الصعب للغاية تلويث مساحة الاسم العالمية عن طريق الصدفة. (يمكن تعطيل مجمع الأمان مع الخيار bare ، وهو غير ضروري ويتم تعطيله تلقائيًا عند استخدام الوحدات.)

إذا كنت ترغب في إنشاء متغيرات من المستوى الأعلى لاستخدامها في البرامج النصية الأخرى ، فقم بتثبيتها كخصائص على window . إرفاقها كخصائص على كائن exports في CommonJS ؛ أو استخدم modules . إذا كنت تستهدف كل من CommonJS والمتصفح ، فإن المشغل الوجودي (المغطى أدناه) ، يمنحك طريقة موثوقة لمعرفة مكان إضافتها: exports ? this exports ? this .

بما أن CoffeeScript تهتم بكافة التعريفات المتغيرة ، فإنه من غير الممكن الإعلان عن المتغيرات مع ES2015's let أو const . هذا متعمد نشعر أن البساطة التي اكتسبها عدم التفكير في الإعلان المتغير تفوق الفائدة من وجود ثلاث طرق منفصلة لإعلان المتغيرات.

إذا ، وما إلى ذلك ، ما لم يكن ، والتكليف الشرطي

if يمكن كتابة عبارة / else بدون استخدام الأقواس والأقواس المتعرجة. كما هو الحال مع الدالات وعبارات كتلة أخرى ، يتم تحديد الشرط متعدد الخطوط الشرطية بواسطة المسافة البادئة. هناك أيضا شكل postfix مفيد ، مع أو حتى في النهاية.

يمكن لـ Compript ترجمة if عبارات إلى تعابير JavaScript ، باستخدام عامل التشغيل الثلاثي عند الإمكان ، وإغلاق التفاف خلاف ذلك. لا يوجد بيان ثلاثي صريح في CoffeeScript - يمكنك ببساطة استخدام عبارة if رسمية في سطر واحد.

mood = greatlyImproved if singing

if happy and knowsIt
  clapsHands()
  chaChaCha()
else
  showIt()

date = if friday then sue else jill
var date, mood;

if (singing) {
  mood = greatlyImproved;
}

if (happy && knowsIt) {
  clapsHands();
  chaChaCha();
} else {
  showIt();
}

date = friday ? sue : jill;

Splats، أو Rest Parameters / Spread Syntax

يُعد كائن arguments JavaScript وسيلة مفيدة للعمل مع الدالات التي تقبل أعدادًا متغيرة من الوسيطات. يوفر CoffeeScript splats ... ، لكل من تعريف الدالة بالإضافة إلى استدعاء ، مما يجعل الأرقام المتغيرة من الحجج أكثر قبولا. اعتمدت ES2015 هذه الميزة كمعلمات الراحة .

gold = silver = rest = "unknown"

awardMedals = (first, second, others...) ->
  gold   = first
  silver = second
  rest   = others

contenders = [
  "Michael Phelps"
  "Liu Xiang"
  "Yao Ming"
  "Allyson Felix"
  "Shawn Johnson"
  "Roman Sebrle"
  "Guo Jingjing"
  "Tyson Gay"
  "Asafa Powell"
  "Usain Bolt"
]

awardMedals contenders...

alert """
Gold: #{gold}
Silver: #{silver}
The Field: #{rest.join ', '}
"""
var awardMedals, contenders, gold, rest, silver;

gold = silver = rest = "unknown";

awardMedals = function(first, second, ...others) {
  gold = first;
  silver = second;
  return rest = others;
};

contenders = ["Michael Phelps", "Liu Xiang", "Yao Ming", "Allyson Felix", "Shawn Johnson", "Roman Sebrle", "Guo Jingjing", "Tyson Gay", "Asafa Powell", "Usain Bolt"];

awardMedals(...contenders);

alert(`Gold: ${gold}\nSilver: ${silver}\nThe Field: ${rest.join(', ')}`);

تتيح لنا الصفات أيضًا إمكانية إخفاء عناصر الصفيف ...

popular  = ['pepperoni', 'sausage', 'cheese']
unwanted = ['anchovies', 'olives']

all = [popular..., unwanted..., 'mushrooms']
var all, popular, unwanted;

popular = ['pepperoni', 'sausage', 'cheese'];

unwanted = ['anchovies', 'olives'];

all = [...popular, ...unwanted, 'mushrooms'];

... وخصائص الكائن.

user =
  name: 'Werner Heisenberg'
  occupation: 'theoretical physicist'

currentUser = { user..., status: 'Uncertain' }
var currentUser, user,
  _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

user = {
  name: 'Werner Heisenberg',
  occupation: 'theoretical physicist'
};

currentUser = _extends({}, user, {
  status: 'Uncertain'
});

في ECMAScript يطلق على هذا الاسم صيغة الانتشار ، وقد تم دعمها للصفائف منذ ES2015 ولكنها ستأتي قريبًا للكائنات . إلى أن يتم دعم صيغة تركيب الجملة رسميًا ، يخرج مترجم CoffeeScript نفس المطحنة التي يستخدمها تحويل Babel المتبقي ؛ ولكن بمجرد دعمه ، سنقوم بمراجعة إخراج المجمع. لاحظ أن هناك اختلافات دقيقة للغاية بين polyfill والاقتراح الحالي.

الحل والفهم

معظم الحلقات التي ستكتبها في CoffeeScript ستكون عبارة عن فهرسة على المصفوفات والأشياء والنطاقات. تستبدل الفروق (وتجميعها) للحلقات ، مع جمل الحماية الاختيارية وقيمة فهرس الصفيف الحالي. على عكس الحلقات ، تعتبر فُرَج الصفيفات تعابير ، ويمكن إعادتها وتعيينها.

# Eat lunch.
eat = (food) -> "#{food} eaten."
eat food for food in ['toast', 'cheese', 'wine']

# Fine five course dining.
courses = ['greens', 'caviar', 'truffles', 'roast', 'cake']
menu = (i, dish) -> "Menu Item #{i}: #{dish}" 
menu i + 1, dish for dish, i in courses

# Health conscious meal.
foods = ['broccoli', 'spinach', 'chocolate']
eat food for food in foods when food isnt 'chocolate'
// Eat lunch.
var courses, dish, eat, food, foods, i, j, k, l, len, len1, len2, menu, ref;

eat = function(food) {
  return `${food} eaten.`;
};

ref = ['toast', 'cheese', 'wine'];
for (j = 0, len = ref.length; j < len; j++) {
  food = ref[j];
  eat(food);
}

// Fine five course dining.
courses = ['greens', 'caviar', 'truffles', 'roast', 'cake'];

menu = function(i, dish) {
  return `Menu Item ${i}: ${dish}`;
};

for (i = k = 0, len1 = courses.length; k < len1; i = ++k) {
  dish = courses[i];
  menu(i + 1, dish);
}

// Health conscious meal.
foods = ['broccoli', 'spinach', 'chocolate'];

for (l = 0, len2 = foods.length; l < len2; l++) {
  food = foods[l];
  if (food !== 'chocolate') {
    eat(food);
  }
}

يجب أن تكون قادرة على التعامل مع معظم الأماكن التي قد تستخدم فيها حلقة أخرى ، each / forEach ، أو map ، أو select / filter ، على سبيل المثال:
shortNames = (name for name in list when name.length < 5)
إذا كنت تعرف بداية الحلقة ونهايتها ، أو كنت ترغب في المرور بزيادات ذات حجم ثابت ، فيمكنك استخدام نطاق لتحديد بداية الاستيعاب ونهايته.

countdown = (num for num in [10..1])
var countdown, num;

countdown = (function() {
  var i, results;
  results = [];
  for (num = i = 10; i >= 1; num = --i) {
    results.push(num);
  }
  return results;
})();

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

للدخول إلى مجموعة من الفهم في قطع بحجم ثابت ، استخدمها ، على سبيل المثال: evens = (x for x in [0..10] by 2)

إذا لم تكن بحاجة إلى قيمة التكرار الحالية ، فيمكنك حذفها: browser.closeCurrentTab() for [0...count]

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

yearsOld = max: 10, ida: 9, tim: 11

ages = for child, age of yearsOld
  "#{child} is #{age}"
var age, ages, child, yearsOld;

yearsOld = {
  max: 10,
  ida: 9,
  tim: 11
};

ages = (function() {
  var results;
  results = [];
  for (child in yearsOld) {
    age = yearsOld[child];
    results.push(`${child} is ${age}`);
  }
  return results;
})();

إذا كنت ترغب في التكرار أكثر من مجرد المفاتيح التي تم تعريفها على الكائن نفسه ، عن طريق إضافة فحص hasOwnProperty لتجنب الخصائص التي قد تكون موروثة من النموذج الأولي ، استخدم for own key, value of object .

لتكرار وظيفة المولد ، استخدم from . انظر وظائف مولد .

الحلقة الوحيدة ذات المستوى المنخفض التي توفرها CoffeeScript هي الحلقة الزمنية. الاختلاف الرئيسي من JavaScript هو أنه يمكن استخدام حلقة while كتعبير ، مع إعادة مصفوفة تحتوي على نتيجة كل تكرار من خلال الحلقة.

# Econ 101
if this.studyingEconomics
  buy()  while supply > demand
  sell() until supply > demand

# Nursery Rhyme
num = 6
lyrics = while num -= 1
  "#{num} little monkeys, jumping on the bed.
    One fell out and bumped his head."
// Econ 101
var lyrics, num;

if (this.studyingEconomics) {
  while (supply > demand) {
    buy();
  }
  while (!(supply > demand)) {
    sell();
  }
}

// Nursery Rhyme
num = 6;

lyrics = (function() {
  var results;
  results = [];
  while (num -= 1) {
    results.push(`${num} little monkeys, jumping on the bed. One fell out and bumped his head.`);
  }
  return results;
})();

بالنسبة لقابلية القراءة ، تعادل الكلمة الرئيسية until while not الكلمة الرئيسية loop تساوي while true .

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

for filename in list
  do (filename) ->
    if filename not in ['.DS_Store', 'Thumbs.db', 'ehthumbs.db']
      fs.readFile filename, (err, contents) ->
        compile filename, contents.toString()
var filename, i, len;

for (i = 0, len = list.length; i < len; i++) {
  filename = list[i];
  (function(filename) {
    if (filename !== '.DS_Store' && filename !== 'Thumbs.db' && filename !== 'ehthumbs.db') {
      return fs.readFile(filename, function(err, contents) {
        return compile(filename, contents.toString());
      });
    }
  })(filename);
}

مصفوفة تقطيع وتشبيك مع نطاقات

يمكن استخدام النطاقات لاستخراج شرائح المصفوفات. مع وجود نقطتين ( 3..6 ) ، يكون النطاق شاملاً ( 3, 4, 5, 6 ) ؛ مع ثلاث نقاط ( 3...6 ) ، يستثني النطاق النهاية ( 3, 4, 5 ). تحتوي مؤشرات الشرائح على قيم افتراضية مفيدة. يفترض الفهرس الأول الذي تم حذفه صفرًا ، ويتم تعيين الفهرس الثاني الذي تم تجاهله إلى حجم الصفيف.

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

start   = numbers[0..2]

middle  = numbers[3...-2]

end     = numbers[-2..]

copy    = numbers[..]
var copy, end, middle, numbers, start;

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9];

start = numbers.slice(0, 3);

middle = numbers.slice(3, -2);

end = numbers.slice(-2);

copy = numbers.slice(0);

يمكن استخدام نفس البنية اللغوية مع التعيين لاستبدال جزء من مصفوفة بقيم جديدة ، مع ربطها.

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

numbers[3..6] = [-3, -4, -5, -6]
var numbers, ref,
  splice = [].splice;

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

splice.apply(numbers, [3, 4].concat(ref = [-3, -4, -5, -6])), ref;

لاحظ أن سلاسل جافا سكريبت غير قابلة للتغيير ولا يمكن تقطيعها.

كل شيء هو تعبير (على الأقل ، قدر الإمكان)

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

grade = (student) ->
  if student.excellentWork
    "A+"
  else if student.okayStuff
    if student.triedHard then "B" else "B-"
  else
    "C"

eldest = if 24 > 21 then "Liz" else "Ike"
var eldest, grade;

grade = function(student) {
  if (student.excellentWork) {
    return "A+";
  } else if (student.okayStuff) {
    if (student.triedHard) {
      return "B";
    } else {
      return "B-";
    }
  } else {
    return "C";
  }
};

eldest = 24 > 21 ? "Liz" : "Ike";

على الرغم من أن الدالات ستعود دائمًا إلى قيمتها النهائية ، إلا أنه من الممكن وتشجيعها على العودة مبكراً من هيئة وظيفية تكتب العودة الصريحة ( return value ) ، عندما تعرف أنك انتهيت.

نظرًا لأن التعريفات المتغيرة تحدث في أعلى النطاق ، فيمكن استخدام التعيين ضمن التعبيرات ، حتى بالنسبة للمتغيرات التي لم يتم رؤيتها من قبل:

six = (one = 1) + (two = 2) + (three = 3)
var one, six, three, two;

six = (one = 1) + (two = 2) + (three = 3);

يتم تحويل الأشياء التي قد تكون عبارات بطريقة أخرى في JavaScript ، عند استخدامها كجزء من تعبير في CoffeeScript ، إلى تعبيرات بلفها في إغلاق. يتيح لك ذلك القيام بأشياء مفيدة ، مثل تعيين نتيجة فهم متغير:

# The first ten global properties.

globals = (name for name of window)[0...10]
// The first ten global properties.
var globals, name;

globals = ((function() {
  var results;
  results = [];
  for (name in window) {
    results.push(name);
  }
  return results;
})()).slice(0, 10);

بالإضافة إلى الأشياء السخيفة ، مثل تمرير عبارة try / catch مباشرة إلى استدعاء دالة:

alert(
  try
    nonexistent / undefined
  catch error
    "And the error is ... #{error}"
)
var error;

alert((function() {
  try {
    return nonexistent / void 0;
  } catch (error1) {
    error = error1;
    return `And the error is ... ${error}`;
  }
})());

There are a handful of statements in JavaScript that can't be meaningfully converted into expressions, namely break , continue , and return . If you make use of them within a block of code, CoffeeScript won't try to perform the conversion.

Operators and Aliases

Because the == operator frequently causes undesirable coercion, is intransitive, and has a different meaning than in other languages, CoffeeScript compiles == into === , and != into !== . In addition, is compiles into === , and isnt into !== .

You can use not as an alias for ! .

For logic, and compiles to && , and or into || .

Instead of a newline or semicolon, then can be used to separate conditions from expressions, in while , if / else , and switch / when statements.

As in YAML , on and yes are the same as boolean true , while off and no are boolean false .

unless can be used as the inverse of if .

As a shortcut for this.property , you can use @property .

You can use in to test for array presence, and of to test for JavaScript object-key presence.

In a for loop, from compiles to the ES2015 of . (Yes, it's unfortunate; the CoffeeScript of predates the ES2015 of .)

To simplify math expressions, ** can be used for exponentiation and // performs floor division. % works just like in JavaScript, while %% provides “dividend dependent modulo” :

-7 % 5 == -2 # The remainder of 7 / 5
-7 %% 5 == 3 # n %% 5 is always between 0 and 4

tabs.selectTabAtIndex((tabs.currentIndex - count) %% tabs.length)
var modulo = function(a, b) { return (+a % (b = +b) + b) % b; };

-7 % 5 === -2; // The remainder of 7 / 5

modulo(-7, 5) === 3; // n %% 5 is always between 0 and 4

tabs.selectTabAtIndex(modulo(tabs.currentIndex - count, tabs.length));

All together now:

CoffeeScript جافا سكريبت
is ===
isnt !==
not !
and &&
or ||
true , yes , on true
false , no , off false
@ , this this
a in b [].indexOf.call(b, a) >= 0
a of b a in b
for a from b for (a of b)
a ** b Math.pow(a, b)
a // b Math.floor(a / b)
a %% b (a % b + b) % b
launch() if ignition is on

volume = 10 if band isnt SpinalTap

letTheWildRumpusBegin() unless answer is no

if car.speed < limit then accelerate()

winner = yes if pick in [47, 92, 13]

print inspect "My name is #{@name}"
var volume, winner;

if (ignition === true) {
  launch();
}

if (band !== SpinalTap) {
  volume = 10;
}

if (answer !== false) {
  letTheWildRumpusBegin();
}

if (car.speed < limit) {
  accelerate();
}

if (pick === 47 || pick === 92 || pick === 13) {
  winner = true;
}

print(inspect(`My name is ${this.name}`));

The Existential Operator

It's a little difficult to check for the existence of a variable in JavaScript. if (variable) … comes close, but fails for zero, the empty string, and false (to name just the most common cases). CoffeeScript's existential operator ? returns true unless a variable is null or undefined or undeclared, which makes it analogous to Ruby's nil? .

It can also be used for safer conditional assignment than the JavaScript pattern a = a || value provides, for cases where you may be handling numbers or strings.

solipsism = true if mind? and not world?

speed = 0
speed ?= 15

footprints = yeti ? "bear"
var footprints, solipsism, speed;

if ((typeof mind !== "undefined" && mind !== null) && (typeof world === "undefined" || world === null)) {
  solipsism = true;
}

speed = 0;

if (speed == null) {
  speed = 15;
}

footprints = typeof yeti !== "undefined" && yeti !== null ? yeti : "bear";

Note that if the compiler knows that a is in scope and therefore declared, a? compiles to a != null , not a !== null . The != makes a loose comparison to null , which does double duty also comparing against undefined . The reverse also holds for not a? or unless a? .

major = 'Computer Science'

unless major?
  signUpForClass 'Introduction to Wines'
var major;

major = 'Computer Science';

if (major == null) {
  signUpForClass('Introduction to Wines');
}

If a variable might be undeclared, the compiler does a thorough check. This is what JavaScript coders should be typing when they want to check if a mystery variable exists.

if window?
  environment = 'browser (probably)'
var environment;

if (typeof window !== "undefined" && window !== null) {
  environment = 'browser (probably)';
}

The accessor variant of the existential operator ?. can be used to soak up null references in a chain of properties. Use it instead of the dot accessor . in cases where the base value may be null or undefined . If all of the properties exist then you'll get the expected result, if the chain is broken, undefined is returned instead of the TypeError that would be raised otherwise.

zip = lottery.drawWinner?().address?.zipcode
var ref, zip;

zip = typeof lottery.drawWinner === "function" ? (ref = lottery.drawWinner().address) != null ? ref.zipcode : void 0 : void 0;

For completeness:

مثال Definition
a? tests that a is in scope and a != null
a ? b returns a if a is in scope and a != null ; otherwise, b
a?.b or a?['b'] returns ab if a is in scope and a != null ; otherwise, undefined
a?(b, c) or a? b, c returns the result of calling a (with arguments b and c ) if a is in scope and callable; otherwise, undefined
a ?= b assigns the value of b to a if a is not in scope or if a == null ; produces the new value of a

Chaining Function Calls

Leading . closes all open calls, allowing for simpler chaining syntax.

$ 'body'
.click (e) ->
  $ '.box'
  .fadeIn 'fast'
  .addClass 'show'
.css 'background', 'white'
$('body').click(function(e) {
  return $('.box').fadeIn('fast').addClass('show');
}).css('background', 'white');

Destructuring Assignment

Just like JavaScript (since ES2015), CoffeeScript has destructuring assignment syntax. When you assign an array or object literal to a value, CoffeeScript breaks up and matches both sides against each other, assigning the values on the right to the variables on the left. In the simplest case, it can be used for parallel assignment:

theBait   = 1000
theSwitch = 0

[theBait, theSwitch] = [theSwitch, theBait]
var theBait, theSwitch;

theBait = 1000;

theSwitch = 0;

[theBait, theSwitch] = [theSwitch, theBait];

But it's also helpful for dealing with functions that return multiple values.

weatherReport = (location) ->
  # Make an Ajax request to fetch the weather...
  [location, 72, "Mostly Sunny"]

[city, temp, forecast] = weatherReport "Berkeley, CA"
var city, forecast, temp, weatherReport;

weatherReport = function(location) {
  // Make an Ajax request to fetch the weather...
  return [location, 72, "Mostly Sunny"];
};

[city, temp, forecast] = weatherReport("Berkeley, CA");

Destructuring assignment can be used with any depth of array and object nesting, to help pull out deeply nested properties.

futurists =
  sculptor: "Umberto Boccioni"
  painter:  "Vladimir Burliuk"
  poet:
    name:   "F.T. Marinetti"
    address: [
      "Via Roma 42R"
      "Bellagio, Italy 22021"
    ]

{sculptor} = futurists

{poet: {name, address: [street, city]}} = futurists
var city, futurists, name, sculptor, street;

futurists = {
  sculptor: "Umberto Boccioni",
  painter: "Vladimir Burliuk",
  poet: {
    name: "F.T. Marinetti",
    address: ["Via Roma 42R", "Bellagio, Italy 22021"]
  }
};

({sculptor} = futurists);

({
  poet: {
    name,
    address: [street, city]
  }
} = futurists);

Destructuring assignment can even be combined with splats.

tag = "<impossible>"

[open, contents..., close] = tag.split("")
var close, contents, open, ref, tag,
  splice = [].splice;

tag = "<impossible>";

ref = tag.split(""), [open, ...contents] = ref, [close] = splice.call(contents, -1);

Expansion can be used to retrieve elements from the end of an array without having to assign the rest of its values. It works in function parameter lists as well.

text = "Every literary critic believes he will
        outwit history and have the last word"

[first, ..., last] = text.split " "
var first, last, ref, text,
  slice = [].slice;

text = "Every literary critic believes he will outwit history and have the last word";

ref = text.split(" "), [first] = ref, [last] = slice.call(ref, -1);

Destructuring assignment is also useful when combined with class constructors to assign properties to your instance from an options object passed to the constructor.

class Person
  constructor: (options) ->
    {@name, @age, @height = 'average'} = options

tim = new Person name: 'Tim', age: 4
var Person, tim;

Person = class Person {
  constructor(options) {
    ({name: this.name, age: this.age, height: this.height = 'average'} = options);
  }

};

tim = new Person({
  name: 'Tim',
  age: 4
});

The above example also demonstrates that if properties are missing in the destructured object or array, you can, just like in JavaScript, provide defaults. Note though that unlike with the existential operator, the default is only applied with the value is missing or undefinedpassing null will set a value of null , not the default.

Bound (Fat Arrow) Functions

In JavaScript, the this keyword is dynamically scoped to mean the object that the current function is attached to. If you pass a function as a callback or attach it to a different object, the original value of this will be lost. If you're not familiar with this behavior, this Digital Web article gives a good overview of the quirks.

The fat arrow => can be used to both define a function, and to bind it to the current value of this , right on the spot. This is helpful when using callback-based libraries like Prototype or jQuery, for creating iterator functions to pass to each , or event-handler functions to use with on . Functions created with the fat arrow are able to access properties of the this where they're defined.

Account = (customer, cart) ->
  @customer = customer
  @cart = cart

  $('.shopping_cart').on 'click', (event) =>
    @customer.purchase @cart
var Account;

Account = function(customer, cart) {
  this.customer = customer;
  this.cart = cart;
  return $('.shopping_cart').on('click', (event) => {
    return this.customer.purchase(this.cart);
  });
};

If we had used -> in the callback above, @customer would have referred to the undefined “customer” property of the DOM element, and trying to call purchase() on it would have raised an exception.

The fat arrow was one of the most popular features of CoffeeScript, and ES2015 adopted it ; so CoffeeScript 2 compiles => to ES => .

Generator Functions

CoffeeScript supports ES2015 generator functions through the yield keyword. There's no function*(){} nonsense — a generator in CoffeeScript is simply a function that yields.

perfectSquares = ->
  num = 0
  loop
    num += 1
    yield num * num
  return

window.ps or= perfectSquares()
var perfectSquares;

perfectSquares = function*() {
  var num;
  num = 0;
  while (true) {
    num += 1;
    yield num * num;
  }
};

window.ps || (window.ps = perfectSquares());

yield* is called yield from , and yield return may be used if you need to force a generator that doesn't yield.

You can iterate over a generator function using for…from .

fibonacci = ->
  [previous, current] = [1, 1]
  loop
    [previous, current] = [current, previous + current]
    yield current
  return

getFibonacciNumbers = (length) ->
  results = [1]
  for n from fibonacci()
    results.push n
    break if results.length is length
  results
var fibonacci, getFibonacciNumbers;

fibonacci = function*() {
  var current, previous;
  [previous, current] = [1, 1];
  while (true) {
    [previous, current] = [current, previous + current];
    yield current;
  }
};

getFibonacciNumbers = function(length) {
  var n, ref, results;
  results = [1];
  ref = fibonacci();
  for (n of ref) {
    results.push(n);
    if (results.length === length) {
      break;
    }
  }
  return results;
};

Async Functions

ES2017's async functions are supported through the await keyword. Like with generators, there's no need for an async keyword; an async function in CoffeeScript is simply a function that awaits.

Similar to how yield return forces a generator, await return may be used to force a function to be async.

# Your browser must support async/await and speech synthesis
# to run this example.

sleep = (ms) ->
  new Promise (resolve) ->
    window.setTimeout resolve, ms

say = (text) ->
  window.speechSynthesis.cancel()
  window.speechSynthesis.speak new SpeechSynthesisUtterance text

countdown = (seconds) ->
  for i in [seconds..1]
    say i
    await sleep 1000 # wait one second
  say "Blastoff!"

countdown 3
// Your browser must support async/await and speech synthesis
// to run this example.
var countdown, say, sleep;

sleep = function(ms) {
  return new Promise(function(resolve) {
    return window.setTimeout(resolve, ms);
  });
};

say = function(text) {
  window.speechSynthesis.cancel();
  return window.speechSynthesis.speak(new SpeechSynthesisUtterance(text));
};

countdown = async function(seconds) {
  var i, j, ref;
  for (i = j = ref = seconds; (ref <= 1 ? j <= 1 : j >= 1); i = ref <= 1 ? ++j : --j) {
    say(i);
    await sleep(1000); // wait one second
  }
  return say("Blastoff!");
};

countdown(3);

الطبقات

CoffeeScript 1 provided the class and extends keywords as syntactic sugar for working with prototypal functions. With ES2015, JavaScript has adopted those keywords; so CoffeeScript 2 compiles its class and extends keywords to ES2015 classes.

class Animal
  constructor: (@name) ->

  move: (meters) ->
    alert @name + " moved #{meters}m."

class Snake extends Animal
  move: ->
    alert "Slithering..."
    super 5

class Horse extends Animal
  move: ->
    alert "Galloping..."
    super 45

sam = new Snake "Sammy the Python"
tom = new Horse "Tommy the Palomino"

sam.move()
tom.move()
var Animal, Horse, Snake, sam, tom;

Animal = class Animal {
  constructor(name) {
    this.name = name;
  }

  move(meters) {
    return alert(this.name + ` moved ${meters}m.`);
  }

};

Snake = class Snake extends Animal {
  move() {
    alert("Slithering...");
    return super.move(5);
  }

};

Horse = class Horse extends Animal {
  move() {
    alert("Galloping...");
    return super.move(45);
  }

};

sam = new Snake("Sammy the Python");

tom = new Horse("Tommy the Palomino");

sam.move();

tom.move();

Static methods can be defined using @ before the method name:

class Teenager
  @say: (speech) ->
    words = speech.split ' '
    fillers = ['uh', 'um', 'like', 'actually', 'so', 'maybe']
    output = []
    for word, index in words
      output.push word
      output.push fillers[Math.floor(Math.random() * fillers.length)] unless index is words.length - 1
    output.join ', '
var Teenager;

Teenager = class Teenager {
  static say(speech) {
    var fillers, i, index, len, output, word, words;
    words = speech.split(' ');
    fillers = ['uh', 'um', 'like', 'actually', 'so', 'maybe'];
    output = [];
    for (index = i = 0, len = words.length; i < len; index = ++i) {
      word = words[index];
      output.push(word);
      if (index !== words.length - 1) {
        output.push(fillers[Math.floor(Math.random() * fillers.length)]);
      }
    }
    return output.join(', ');
  }

};

Finally, class definitions are blocks of executable code, which make for interesting metaprogramming possibilities. In the context of a class definition, this is the class object itself; therefore, you can assign static properties by using @property: value .

Prototypal Inheritance

In addition to supporting ES2015 classes, CoffeeScript provides a shortcut for working with prototypes. The :: operator gives you quick access to an object's prototype:

String::dasherize = ->
  this.replace /_/g, "-"
String.prototype.dasherize = function() {
  return this.replace(/_/g, "-");
};

Switch/When/Else

switch statements in JavaScript are a bit awkward. You need to remember to break at the end of every case statement to avoid accidentally falling through to the default case. CoffeeScript prevents accidental fall-through, and can convert the switch into a returnable, assignable expression. The format is: switch condition, when clauses, else the default case.

As in Ruby, switch statements in CoffeeScript can take multiple values for each when clause. If any of the values match, the clause runs.

switch day
  when "Mon" then go work
  when "Tue" then go relax
  when "Thu" then go iceFishing
  when "Fri", "Sat"
    if day is bingoDay
      go bingo
      go dancing
  when "Sun" then go church
  else go work
switch (day) {
  case "Mon":
    go(work);
    break;
  case "Tue":
    go(relax);
    break;
  case "Thu":
    go(iceFishing);
    break;
  case "Fri":
  case "Sat":
    if (day === bingoDay) {
      go(bingo);
      go(dancing);
    }
    break;
  case "Sun":
    go(church);
    break;
  default:
    go(work);
}

switch statements can also be used without a control expression, turning them in to a cleaner alternative to if / else chains.

score = 76
grade = switch
  when score < 60 then 'F'
  when score < 70 then 'D'
  when score < 80 then 'C'
  when score < 90 then 'B'
  else 'A'
# grade == 'C'
var grade, score;

score = 76;

grade = (function() {
  switch (false) {
    case !(score < 60):
      return 'F';
    case !(score < 70):
      return 'D';
    case !(score < 80):
      return 'C';
    case !(score < 90):
      return 'B';
    default:
      return 'A';
  }
})();

// grade == 'C'

Try/Catch/Finally

try expressions have the same semantics as try statements in JavaScript, though in CoffeeScript, you may omit both the catch and finally parts. The catch part may also omit the error parameter if it is not needed.

try
  allHellBreaksLoose()
  catsAndDogsLivingTogether()
catch error
  print error
finally
  cleanUp()
var error;

try {
  allHellBreaksLoose();
  catsAndDogsLivingTogether();
} catch (error1) {
  error = error1;
  print(error);
} finally {
  cleanUp();
}

Chained Comparisons

CoffeeScript borrows chained comparisons from Python — making it easy to test if a value falls within a certain range.

cholesterol = 127

healthy = 200 > cholesterol > 60
var cholesterol, healthy;

cholesterol = 127;

healthy = (200 > cholesterol && cholesterol > 60);

Block Regular Expressions

Similar to block strings and comments, CoffeeScript supports block regexes — extended regular expressions that ignore internal whitespace and can contain comments and interpolation. Modeled after Perl's /x modifier, CoffeeScript's block regexes are delimited by /// and go a long way towards making complex regular expressions readable. To quote from the CoffeeScript source:

NUMBER     = ///
  ^ 0b[01]+    |              # binary
  ^ 0o[0-7]+   |              # octal
  ^ 0x[\da-f]+ |              # hex
  ^ \d*\.?\d+ (?:e[+-]?\d+)?  # decimal
///i
var NUMBER;

NUMBER = /^0b[01]+|^0o[0-7]+|^0x[\da-f]+|^\d*\.?\d+(?:e[+-]?\d+)?/i; // binary
// octal
// hex
// decimal

Tagged Template Literals

CoffeeScript supports ES2015 tagged template literals , which enable customized string interpolation. If you immediately prefix a string with a function name (no space between the two), CoffeeScript will output this “function plus string” combination as an ES2015 tagged template literal, which will behave accordingly : the function is called, with the parameters being the input text and expression parts that make up the interpolated string. The function can then assemble these parts into an output string, providing custom string interpolation.

upperCaseExpr = (textParts, expressions...) ->
  textParts.reduce (text, textPart, i) ->
    text + expressions[i - 1].toUpperCase() + textPart

greet = (name, adjective) ->
  upperCaseExpr"""
               Hi #{name}. You look #{adjective}!
               """
var greet, upperCaseExpr;

upperCaseExpr = function(textParts, ...expressions) {
  return textParts.reduce(function(text, textPart, i) {
    return text + expressions[i - 1].toUpperCase() + textPart;
  });
};

greet = function(name, adjective) {
  return upperCaseExpr`Hi ${name}. You look ${adjective}!`;
};

وحدات

ES2015 modules are supported in CoffeeScript, with very similar import and export syntax:

import 'local-file.coffee'
import 'coffeescript'

import _ from 'underscore'
import * as underscore from 'underscore'

import { now } from 'underscore'
import { now as currentTimestamp } from 'underscore'
import { first, last } from 'underscore'
import utilityBelt, { each } from 'underscore'

export default Math
export square = (x) -> x * x
export class Mathematics
  least: (x, y) -> if x < y then x else y

export { sqrt }
export { sqrt as squareRoot }
export { Mathematics as default, sqrt as squareRoot }

export * from 'underscore'
export { max, min } from 'underscore'
import 'local-file.coffee';

import 'coffeescript';

import _ from 'underscore';

import * as underscore from 'underscore';

import {
  now
} from 'underscore';

import {
  now as currentTimestamp
} from 'underscore';

import {
  first,
  last
} from 'underscore';

import utilityBelt, {
  each
} from 'underscore';

export default Math;

export var square = function(x) {
  return x * x;
};

export var Mathematics = class Mathematics {
  least(x, y) {
    if (x < y) {
      return x;
    } else {
      return y;
    }
  }

};

export {
  sqrt
};

export {
  sqrt as squareRoot
};

export {
  Mathematics as default,
  sqrt as squareRoot
};

export * from 'underscore';

export {
  max,
  min
} from 'underscore';

Note that the CoffeeScript compiler does not resolve modules ; writing an import or export statement in CoffeeScript will produce an import or export statement in the resulting output. It is your responsibility attach another transpiler, such as Traceur Compiler , Babel or Rollup , to convert this ES2015 syntax into code that will work in your target runtimes.

Also note that any file with an import or export statement will be output without a top-level function safety wrapper ; in other words, importing or exporting modules will automatically trigger bare mode for that file. This is because per the ES2015 spec, import or export statements must occur at the topmost scope.

Embedded JavaScript

Hopefully, you'll never need to use it, but if you ever need to intersperse snippets of JavaScript within your CoffeeScript, you can use backticks to pass it straight through.

hi = `function() {
  return [document.title, "Hello JavaScript"].join(": ");
}`
var hi;

hi = function() {
  return [document.title, "Hello JavaScript"].join(": ");
};

Escape backticks with backslashes: \`​ becomes `​ .

Escape backslashes before backticks with more backslashes: \\\`​ becomes \`​ .

markdown = `function () {
  return \`In Markdown, write code like \\\`this\\\`\`;
}`
var markdown;

markdown = function () {
  return `In Markdown, write code like \`this\``;
};

You can also embed blocks of JavaScript using triple backticks. That's easier than escaping backticks, if you need them inside your JavaScript block.

```
function time() {
  return `The time is ${new Date().toLocaleTimeString()}`;
}
```
function time() {
  return `The time is ${new Date().toLocaleTimeString()}`;
}
;

JSX

JSX is JavaScript containing interspersed XML elements. While conceived for React , it is not specific to any particular library or framework.

CoffeeScript supports interspersed XML elements, without the need for separate plugins or special settings. The XML elements will be compiled as such, outputting JSX that could be parsed like any normal JSX file, for example by transform-react-jsx . CoffeeScript does not output React.createElement calls or any code specific to React or any other framework. It is up to you to attach another step in your build chain to convert this JSX to whatever function calls you wish the XML elements to compile to.

Just like in JSX and HTML, denote XML tags using < and > . You can interpolate CoffeeScript code inside a tag using { and } . To avoid compiler errors, when using < and > to mean “less than” or “greater than,” you should wrap the operators in spaces to distinguish them from XML tags. So i < len , not i<len . The compiler tries to be forgiving when it can be sure what you intend, but always putting spaces around the “less than” and “greater than” operators will remove ambiguity.

renderStarRating = ({ rating, maxStars }) ->
  <aside title={"Rating: #{rating} of #{maxStars} stars"}>
    {for wholeStar in [0...Math.floor(rating)]
      <Star className="wholeStar" key={wholeStar} />}
    {if rating % 1 isnt 0
      <Star className="halfStar" />}
    {for emptyStar in [Math.ceil(rating)...maxStars]
      <Star className="emptyStar" key={emptyStar} />}
  </aside>
var renderStarRating;

renderStarRating = function({rating, maxStars}) {
  var emptyStar, wholeStar;
  return <aside title={`Rating: ${rating} of ${maxStars} stars`}>
    {(function() {
    var i, ref, results;
    results = [];
    for (wholeStar = i = 0, ref = Math.floor(rating); (0 <= ref ? i < ref : i > ref); wholeStar = 0 <= ref ? ++i : --i) {
      results.push(<Star className="wholeStar" key={wholeStar} />);
    }
    return results;
  })()}
    {(rating % 1 !== 0 ? <Star className="halfStar" /> : void 0)}
    {(function() {
    var i, ref, ref1, results;
    results = [];
    for (emptyStar = i = ref = Math.ceil(rating), ref1 = maxStars; (ref <= ref1 ? i < ref1 : i > ref1); emptyStar = ref <= ref1 ? ++i : --i) {
      results.push(<Star className="emptyStar" key={emptyStar} />);
    }
    return results;
  })()}
  </aside>;
};

Older plugins or forks of CoffeeScript supported JSX syntax and referred to it as CSX or CJSX. They also often used a .cjsx file extension, but this is no longer necessary; regular .coffee will do.

Type Annotations

Static type checking can be achieved in CoffeeScript by using Flow 's Comment Types syntax :

# @flow

###::
type Obj = {
  num: number,
};
###

fn = (str ###: string ###, obj ###: Obj ###) ###: string ### ->
  str + obj.num
// @flow
/*::
type Obj = {
  num: number,
};
*/
var fn;

fn = function(str/*: string */, obj/*: Obj */)/*: string */ {
  return str + obj.num;
};

CoffeeScript does not do any type checking itself; the JavaScript output you see above needs to get passed to Flow for it to validate your code. We expect most people will use a build tool for this, but here's how to do it the simplest way possible using the CoffeeScript and Flow command-line tools, assuming you've already installed Flow and the latest CoffeeScript in your project folder:

coffee --bare --no-header --compile app.coffee && npm run flow

--bare and --no-header are important because Flow requires the first line of the file to be the comment // @flow . If you configure your build chain to compile CoffeeScript and pass the result to Flow in-memory, you can get better performance than this example; and a proper build tool should be able to watch your CoffeeScript files and recompile and type-check them for you on save.

If you know of another way to achieve static type checking with CoffeeScript, please create an issue and let us know.

Literate CoffeeScript

Besides being used as an ordinary programming language, CoffeeScript may also be written in “literate” mode. If you name your file with a .litcoffee extension, you can write it as a Markdown document — a document that also happens to be executable CoffeeScript code. The compiler will treat any indented blocks (Markdown's way of indicating source code) as executable code, and ignore the rest as comments. Code blocks must also be separated from comments by at least one blank line.

Just for kicks, a little bit of the compiler is currently implemented in this fashion: See it as a document , raw , and properly highlighted in a text editor .

A few caveats:

  • Code blocks need to maintain consistent indentation relative to each other. When the compiler parses your Literate CoffeeScript file, it first discards all the non-code block lines and then parses the remainder as a regular CoffeeScript file. Therefore the code blocks need to be written as if the comment lines don't exist, with consistent indentation (including whether they are indented with tabs or spaces).
  • Along those lines, code blocks within list items or blockquotes are not treated as executable code. Since list items and blockquotes imply their own indentation, it would be ambiguous how to treat indentation between successive code blocks when some are within these other blocks and some are not.
  • List items can be at most only one paragraph long. The second paragraph of a list item would be indented after a blank line, and therefore indistinguishable from a code block.

Source Maps

CoffeeScript includes support for generating source maps, a way to tell your JavaScript engine what part of your CoffeeScript program matches up with the code being evaluated. Browsers that support it can automatically use source maps to show your original source code in the debugger. To generate source maps alongside your JavaScript files, pass the --map or -m flag to the compiler.

For a full introduction to source maps, how they work, and how to hook them up in your browser, read the HTML5 Tutorial .

Cake, and Cakefiles

CoffeeScript includes a (very) simple build system similar to Make and Rake . Naturally, it's called Cake, and is used for the tasks that build and test the CoffeeScript language itself. Tasks are defined in a file named Cakefile , and can be invoked by running cake [task] from within the directory. To print a list of all the tasks and options, just type cake .

Task definitions are written in CoffeeScript, so you can put arbitrary code in your Cakefile. Define a task with a name, a long description, and the function to invoke when the task is run. If your task takes a command-line option, you can define the option with short and long flags, and it will be made available in the options object. Here's a task that uses the Node.js API to rebuild CoffeeScript's parser:

fs = require 'fs'

option '-o', '--output [DIR]', 'directory for compiled code'

task 'build:parser', 'rebuild the Jison parser', (options) ->
  require 'jison'
  code = require('./lib/grammar').parser.generate()
  dir  = options.output or 'lib'
  fs.writeFile "#{dir}/parser.js", code
var fs;

fs = require('fs');

option('-o', '--output [DIR]', 'directory for compiled code');

task('build:parser', 'rebuild the Jison parser', function(options) {
  var code, dir;
  require('jison');
  code = require('./lib/grammar').parser.generate();
  dir = options.output || 'lib';
  return fs.writeFile(`${dir}/parser.js`, code);
});

If you need to invoke one task before another — for example, running build before test , you can use the invoke function: invoke 'build' . Cake tasks are a minimal way to expose your CoffeeScript functions to the command line, so don't expect any fanciness built-in . If you need dependencies, or async callbacks, it's best to put them in your code itself — not the cake task.

"text/coffeescript" Script Tags

While it's not recommended for serious use, CoffeeScripts may be included directly within the browser using <script type="text/coffeescript"> tags. The source includes a compressed and minified version of the compiler ( Download current version here, 51k when gzipped ) as docs/v2/browser-compiler/coffeescript.js . Include this file on a page with inline CoffeeScript tags, and it will compile and evaluate them in order.

The usual caveats about CoffeeScript apply — your inline scripts will run within a closure wrapper, so if you want to expose global variables or functions, attach them to the window object.

Unsupported ECMAScript Features

There are a few ECMAScript features that CoffeeScript intentionally doesn't support.

let and const : block-scoped and reassignment-protected variables

When CoffeeScript was designed, var was intentionally omitted . This was to spare developers the mental housekeeping of needing to worry about variable declaration ( var foo ) as opposed to variable assignment ( foo = 1 ). The CoffeeScript compiler automatically takes care of declaration for you, by generating var statements at the top of every function scope. This makes it impossible to accidentally declare a global variable.

let and const add a useful ability to JavaScript in that you can use them to declare variables within a block scope, for example within an if statement body or a for loop body, whereas var always declares variables in the scope of an entire function. When CoffeeScript 2 was designed, there was much discussion of whether this functionality was useful enough to outweigh the simplicity offered by never needing to consider variable declaration in CoffeeScript. In the end, it was decided that the simplicity was more valued. In CoffeeScript there remains only one type of variable.

Keep in mind that const only protects you from reassigning a variable; it doesn't prevent the variable's value from changing, the way constants usually do in other languages:

const obj = {foo: 'bar'};
obj.foo = 'baz'; // Allowed!
obj = {}; // Throws error

Named functions and function declarations

Newcomers to CoffeeScript often wonder how to generate the JavaScript function foo() {} , as opposed to the foo = function() {} that CoffeeScript produces. The first form is a function declaration , and the second is a function expression . As stated above, in CoffeeScript everything is an expression , so naturally we favor the expression form. Supporting only one variant helps avoid confusing bugs that can arise from the subtle differences between the two forms .

Technically, foo = function() {} is creating an anonymous function that gets assigned to a variable named foo . Some very early versions of CoffeeScript named this function, eg foo = function foo() {} , but this was dropped because of compatibility issues with Internet Explorer. For a while this annoyed people, as these functions would be unnamed in stack traces; but modern JavaScript runtimes infer the names of such anonymous functions from the names of the variables to which they're assigned. Given that this is the case, it's simplest to just preserve the current behavior.

get and set keyword shorthand syntax

get and set , as keywords preceding functions or class methods, are intentionally unimplemented in CoffeeScript.

This is to avoid grammatical ambiguity, since in CoffeeScript such a construct looks identical to a function call (eg get(function foo() {}) ); and because there is an alternate syntax that is slightly more verbose but just as effective:

screen =
  width: 1200
  ratio: 16/9

Object.defineProperty screen, 'height',
  get: ->
    this.width / this.ratio
  set: (val) ->
    this.width = val * this.ratio
var screen;

screen = {
  width: 1200,
  ratio: 16 / 9
};

Object.defineProperty(screen, 'height', {
  get: function() {
    return this.width / this.ratio;
  },
  set: function(val) {
    return this.width = val * this.ratio;
  }
});

Breaking Changes From CoffeeScript 1.x to 2

CoffeeScript 2 aims to output as much idiomatic ES2015+ syntax as possible with as few breaking changes from CoffeeScript 1.x as possible. Some breaking changes, unfortunately, were unavoidable.

Bound (fat arrow) functions

In CoffeeScript 1.x, => compiled to a regular function but with references to this / @ rewritten to use the outer scope's this , or with the inner function bound to the outer scope via .bind (hence the name “bound function”). In CoffeeScript 2, => compiles to ES2015's => , which behaves slightly differently. The largest difference is that in ES2015, => functions lack an arguments object:

outer = ->
  inner = => Array.from arguments
  inner()

outer(1, 2)  # Returns '' in CoffeeScript 1.x, '1, 2' in CoffeeScript 2
var outer;

outer = function() {
  var inner;
  inner = () => {
    return Array.from(arguments);
  };
  return inner();
};

outer(1, 2); // Returns '' in CoffeeScript 1.x, '1, 2' in CoffeeScript 2

Default values for function parameters and destructured elements

Per the ES2015 spec regarding function default parameters and destructuring default values , default values are only applied when a value is missing or undefined . In CoffeeScript 1.x, the default value would be applied in those cases but also if the value was null .

f = (a = 1) -> a

f(null)  # Returns 1 in CoffeeScript 1.x, null in CoffeeScript 2
var f;

f = function(a = 1) {
  return a;
};

f(null); // Returns 1 in CoffeeScript 1.x, null in CoffeeScript 2
{a = 1} = {a: null}

a  # Equals 1 in CoffeeScript 1.x, null in CoffeeScript 2
var a;

({a = 1} = {
  a: null
});

a; // Equals 1 in CoffeeScript 1.x, null in CoffeeScript 2

Bound generator functions

Bound generator functions, aka generator arrow functions, aren't allowed in ECMAScript . You can write function* or => , but not both. Therefore, CoffeeScript code like this:

f = => yield this
# Throws a compiler error

Needs to be rewritten the old-fashioned way:

self = this
f = -> yield self
var f, self;

self = this;

f = function*() {
  return (yield self);
};

Classes are compiled to ES2015 classes

ES2015 classes and their methods have some restrictions beyond those on regular functions.

Class constructors can't be invoked without new :

(class)()
# Throws a TypeError at runtime

ES2015 classes don't allow bound (fat arrow) methods. The CoffeeScript compiler goes through some contortions to preserve support for them, but one thing that can't be accommodated is calling a bound method before it is bound:

class Base
  constructor: ->
    @onClick()      # This works
    clickHandler = @onClick
    clickHandler()  # This throws a runtime error

class Component extends Base
  onClick: =>
    console.log 'Clicked!', @

Class methods can't be used with new (uncommon):

class Namespace
  @Klass = ->
new Namespace.Klass  # Throws a TypeError at runtime

Due to the hoisting required to compile to ES2015 classes, dynamic keys in class methods can't use values from the executable class body unless the methods are assigned in prototype style.

class A
  name = 'method'
  "#{name}": ->   # This method will be named 'undefined'
  @::[name] = ->  # This will work; assigns to `A.prototype.method`

super and this

In the constructor of a derived class (a class that extends another class), this cannot be used before calling super :

class B extends A
  constructor: -> this  # Throws a compiler error

This also means you cannot pass a reference to this as an argument to super in the constructor of a derived class:

class B extends A
  constructor: (@arg) ->
    super @arg  # Throws a compiler error

This is a limitation of ES2015 classes. As a workaround, assign to this after the super call:

class B extends A
  constructor: (arg) ->
    super arg
    @arg = arg
var B;

B = class B extends A {
  constructor(arg) {
    super(arg);
    this.arg = arg;
  }

};

super and extends

Due to a syntax clash with super with accessors, “bare” super (the keyword super without parentheses) no longer compiles to a super call forwarding all arguments.

class B extends A
  foo: -> super
  # Throws a compiler error

Arguments can be forwarded explicitly using splats:

class B extends A
  foo: -> super arguments...
var B;

B = class B extends A {
  foo() {
    return super.foo(...arguments);
  }

};

Or if you know that the parent function doesn't require arguments, just call super() :

class B extends A
  foo: -> super()
var B;

B = class B extends A {
  foo() {
    return super.foo();
  }

};

CoffeeScript 1.x allowed the extends keyword to set up prototypal inheritance between functions, and super could be used manually prototype-assigned functions:

A = ->
B = ->
B extends A
B.prototype.foo = -> super arguments...
# Last two lines each throw compiler errors in CoffeeScript 2

Due to the switch to ES2015 extends and super , using these keywords for prototypal functions are no longer supported. The above case could be refactored to:

# Helper functions
hasProp = {}.hasOwnProperty
extend = (child, parent) ->
  ctor = ->
    @constructor = child
    return
  for key of parent
    if hasProp.call(parent, key)
      child[key] = parent[key]
  ctor.prototype = parent.prototype
  child.prototype = new ctor
  child


A = ->
B = ->
extend B, A
B.prototype.foo = -> A::foo.apply this, arguments
// Helper functions
var A, B, extend, hasProp;

hasProp = {}.hasOwnProperty;

extend = function(child, parent) {
  var ctor, key;
  ctor = function() {
    this.constructor = child;
  };
  for (key in parent) {
    if (hasProp.call(parent, key)) {
      child[key] = parent[key];
    }
  }
  ctor.prototype = parent.prototype;
  child.prototype = new ctor;
  return child;
};

A = function() {};

B = function() {};

extend(B, A);

B.prototype.foo = function() {
  return A.prototype.foo.apply(this, arguments);
};

أو

class A
class B extends A
  foo: -> super arguments...
var A, B;

A = class A {};

B = class B extends A {
  foo() {
    return super.foo(...arguments);
  }

};

JSX and the < and > operators

With the addition of JSX , the < and > characters serve as both the “less than” and “greater than” operators and as the delimiters for XML tags, like <div> . For best results, in general you should always wrap the operators in spaces to distinguish them from XML tags: i < len , not i<len . The compiler tries to be forgiving when it can be sure what you intend, but always putting spaces around the “less than” and “greater than” operators will remove ambiguity.

Literate CoffeeScript parsing

CoffeeScript 2's parsing of Literate CoffeeScript has been refactored to now be more careful about not treating indented lists as code blocks; but this means that all code blocks (unless they are to be interpreted as comments) must be separated by at least one blank line from lists.

Code blocks should also now maintain a consistent indentation level—so an indentation of one tab (or whatever you consider to be a tab stop, like 2 spaces or 4 spaces) should be treated as your code's “left margin,” with all code in the file relative to that column.

Code blocks that you want to be part of the commentary, and not executed, must have at least one line (ideally the first line of the block) completely unindented.

Argument parsing and shebang ( #! ) lines

In CoffeeScript 1.x, -- was required after the path and filename of the script to be run, but before any arguments passed to that script. This convention is now deprecated. لذلك بدلا من:

coffee [options] path/to/script.coffee -- [args]

Now you would just type:

coffee [options] path/to/script.coffee [args]

The deprecated version will still work, but it will print a warning before running the script.

On non-Windows platforms, a .coffee file can be made executable by adding a shebang ( #! ) line at the top of the file and marking the file as executable. فمثلا:

#!/usr/bin/env coffee

x = 2 + 2
console.log x

If this were saved as executable.coffee , it could be made executable and run:

▶ chmod +x ./executable.coffee
▶ ./executable.coffee
4

In CoffeeScript 1.x, this used to fail when trying to pass arguments to the script. Some users on OS X worked around the problem by using #!/usr/bin/env coffee -- as the first line of the file. That didn't work on Linux, however, which cannot parse shebang lines with more than a single argument. While such scripts will still run on OS X, CoffeeScript will now display a warning before compiling or evaluating files that begin with a too-long shebang line. Now that CoffeeScript 2 supports passing arguments without needing -- , we recommend simply changing the shebang lines in such scripts to just #!/usr/bin/env coffee .

原文