rarwe.tar.gz

Ember

Ember-copy

ember2

embercss

rarwe

Ember-copy-5yvdqv

Ember-copy-5yvdqv-copy

Ember-Acceptest

Ember-Acceptest-copy

Ember-unitest

rarwe-copy

Ember-Acceptest-challenge

Ember-helper-challenge

In this course, you begin with an introduction to Ember.js, a JavaScript framework for building client-side applications.

After that, the course guides you through the steps of building a real application so that you can see how the concepts are applied in practice. You'll learn about the building blocks of Ember one by one, in a way that crushes the allegedly steep learning curve of the framework.

The application will get shinier (and/or more robust) with each chapter. By the end, we will have a decent app, and you'll have a great new skill you can add to your resume.

Developing Robust Ember.js Applications

## Component invocation
Up until 3.4, we could not invoke components using the angle-bracket invocation syntax we used throughout the course, like `<StarRating ...>`. Instead, we needed to use curly braces with the component’s name in its dasherized form.

Invoking the star-rating component with curly braces, aka. mustaches, looks like:

```js
{{star-rating class="fr" rating=song.rating}}
```
Also, components that had to be callable with curlies, so all components prior to 3.4, needed to have a dash in their name.

## Uses of curly braces
So, why would someone use the curly braces invocation? Two reasons:

1. You have an Ember app before 3.4.
2. You want to use positional parameters when invoking the component.

Positional parameters are passed as just values, not as a value assigned to a key. An example is the curly invocation of the `link-to` component we've been using throughout the app:


```
{{#link-to "bands.band.songs" band.id class="mt-4"}} 2 (...)
3 {{/link-to}
```

Here, `"bands.band.songs"` and `band` are both positional parameters because they are not part of the params hash. Contrast this with:

```js
<LinkTo @route="bands.band.songs" @model={{band.id}} class="mt-4">
```

Here, both parameters are named ones, `@route` and `@model`.

Angle-bracket invocation feels natural because it has the same syntax as HTML tags, but it doesn’t support positional parameters. I haven’t personally found that to be a nuisance, though.

# Component invocation
Up until 3.4, we could not invoke components using the angle-bracket invocation syntax we used throughout the course, like `<StarRating ...>`. Instead, we needed to use curly braces with the component’s name in its dasherized form.

Invoking the star-rating component with curly braces, aka. mustaches, looks like:

```js
{{star-rating class="fr" rating=song.rating}}
```
Also, components that had to be callable with curlies, so all components prior to 3.4, needed to have a dash in their name.

# Uses of curly braces
So, why would someone use the curly braces invocation? Two reasons:

1. You have an Ember app before 3.4.
2. You want to use positional parameters when invoking the component.

Positional parameters are passed as just values, not as a value assigned to a key. An example is the curly invocation of the `link-to` component we've been using throughout the app:


```
{{#link-to "bands.band.songs" band.id class="mt-4"}} 2 (...)
3 {{/link-to}
```

Here, `"bands.band.songs"` and `band` are both positional parameters because they are not part of the params hash. Contrast this with:

```js
<LinkTo @route="bands.band.songs" @model={{band.id}} class="mt-4">
```

Here, both parameters are named ones, `@route` and `@model`.

Angle-bracket invocation feels natural because it has the same syntax as HTML tags, but it doesn’t support positional parameters. I haven’t personally found that to be a nuisance, though.

# Component invocation
Up until 3.4, we could not invoke components using the angle-bracket invocation syntax we used throughout the course, like `<StarRating ...>`. Instead, we needed to use curly braces with the component’s name in its dasherized form.

Invoking the star-rating component with curly braces, aka. mustaches, looks like:

```js
{{star-rating class="fr" rating=song.rating}}
```
Also, components that had to be callable with curlies, so all components prior to 3.4, needed to have a dash in their name.

# Uses of curly braces
So, why would someone use the curly braces invocation? Two reasons:

1. You have an Ember app before 3.4.
2. You want to use positional parameters when invoking the component.

Positional parameters are passed as just values, not as a value assigned to a key. An example is the curly invocation of the `link-to` component we've been using throughout the app:


```
{{#link-to "bands.band.songs" band.id class="mt-4"}} 2 (...)
3 {{/link-to}
```

Here, `"bands.band.songs"` and `band` are both positional parameters because they are not part of the params hash. Contrast this with:

```js
<LinkTo @route="bands.band.songs" @model={{band.id}}>
```

Here, both parameters are named ones, `@route` and `@model`.

Angle-bracket invocation feels natural because it has the same syntax as HTML tags, but it doesn’t support positional parameters. I haven’t personally found that to be a nuisance, though.

In this lesson, you’ll learn about the use of curly braces in Ember.js.

Course Overview

Getting Started with Ember

Templates and Data Bindings

Routing

Nested Routes

Components

Controllers

Building a Catalog

Talking to a Backend

Advanced Routing

Testing

Query Params

Loading and Error Substates

Helpers

Conclusion

Appendix

Curly Braces Component Invocation

Component invocation