Modèle de Chaînes ES6 éviter les sauts de ligne

J'ai une longue chaîne, qui je construis à l'aide de ES6 chaînes du modèle, mais je veux que ce soit sans les sauts de ligne:

var string = `As all string substitutions in Template Strings are JavaScript
              expressions, we can substitute a lot more than variable names.
              For example, below we can use expression interpolation to 
              embed for some readable inline math:`

console.log(string);

Résultat:

As all string substitutions in Template Strings are JavaScript
expressions, we can substitute a lot more than variable names.
For example, below we can use expression interpolation to
embed for some readable inline math:

À mes attentes:

As all string substitutions in Template Strings are JavaScript expressions, we can substitute a lot more than variable names. For example, below we can use expression interpolation to embed for some readable inline math:

s'échapper de la ligne de rupture avec un slash `\` et elle disparaît dans la sortie, même dans les chaînes du modèle.
Doublon de stackoverflow.com/questions/37321047/...

OriginalL'auteur dim0_0n | 2016-06-23

27

Un saut de ligne est un saut de ligne... Si vous les produire manuellement, je trouve très prévisibles que vous obtenez au cours de l'exécution.

BTW, j'ai trouver trois solutions de contournement pour l'instant:
1. Configurer votre IDE ou un éditeur de code pour faire retour de sorte que vous n'aurez pas besoin d'ajouter des sauts de ligne dans votre code si vous n'en avez pas besoin: votre éditeur de casser votre code en deux lignes ou plus si chaque code de la phrase va au-delà de configuré le nombre maximal de caractères.
2. Supprimer les sauts de ligne avec String.prototype.replace:
```
var chaine = `Comme toutes les chaînes de caractères les substitutions de Chaînes du Modèle sont JavaScript 
expressions, nous pouvons substituer un beaucoup plus que les noms de variables. 
Par exemple, ci-dessous, nous pouvons utiliser l'expression de l'interpolation 
intégrer pour certains lisible inline math:`.replace(/\n/g,""); 
```
Attention: ici, vous êtes à l'exécution d'une fonction runtime au format de votre compilation code, qui peut ressembler à un anti-modèle, et avoir d'impact sur les performances
1. Effectuer ces code des sauts de ligne à l'aide de concaténations:
```
var chaine = `Comme toutes les chaînes de caractères les substitutions de Chaînes du Modèle sont JavaScript` 
+ `expressions, nous pouvons substituer un beaucoup plus que les noms de variable.` 
+ `Par exemple, ci-dessous, nous pouvons utiliser l'expression de l'interpolation` 
+ `intégrer pour certains lisible inline math:`; 
```
Dans mon cas, j'irais avec #1 option.

Le deuxième exemple ne fonctionne pas correctement. Elle a de grands écarts entre les lignes.
qu'entendez-vous par de grandes lacunes? Elle contient plus de caractères que le saut de ligne?
copier/coller votre #2 dans la console puis exécutez string. Vous obtenez la chaîne, mais il y a beaucoup d'espaces entre les Javascript et expressions, names. et For example, etc.
Vous ne pouvez pas le voir dans un navigateur, car les navigateurs généralement de supprimer des espaces supplémentaires, mais le sous-jacent de données est incorrect.
oh, je vois, d'ailleurs c'est un problème dans la chaîne elle-même, ne l'approche. De toute façon je vais mettre à jour ma réponse pour résoudre le problème

OriginalL'auteur
24

C'est fou.

Presque chaque seule réponse ici suggèrent l'exécution d'une fonction runtime afin de bien format, compilation mauvais texte au format oO Suis-je le seul choqué par le fait même, en particulier l'impact sur les performances ???

Comme indiqué par @dandavis, le solution officielle, (qui d'ailleur est également l'historique de solution pour les scripts shell unix), est l'espace le retour chariot, ainsi, avec l'espace de caractère : \
```
`foo \
bar` === 'foo bar'
```
Simple, performant, officiel, lisible, et en forme de coquille dans le processus de

Quel est le code de l'indentation?
Cela fonctionne, vous tentez de fuir le carriage return, pas les autres espaces
Il n'y a pas "plus d'espaces", ni de "code indentation" nécessaire. "La façon de le faire" est de ne pas faire cela, et en suivant les normes du code. La façon la plus commune que voyez-vous dans un éditeur de code (j'.e celles qui sont automatiquement le retour à la ligne) n'est pas à re-tiret comme la ligne précédente, il va à la ligne et c'est tout (0 indentation). Si vous voulez vraiment tiret, aller et essayer, HTML imprime uniquement un caractère d'échappement, de toute façon. Si vraiment vous ne voulez vraiment pas à l'x de l'espace des personnages, même si le HTML auto-analyse, de pré-traiter votre code avec un outil qui le fait, mais merci de ne pas exécuter d'exécution pour l'amour de dieu

OriginalL'auteur
18

Si vous avez ES6, vous pouvez utiliser les tags. Par exemple, le stripIndent tag de la commune-les balises de la bibliothèque:

Installer via:
```
npm install common-tags --save
```
Besoin via:
```
const stripIndent = require('common-tags/lib/stripIndent')
```
Utiliser comme:
```
stripIndent`
  As all string substitutions in Template Strings are JavaScript
  expressions, we can substitute a lot more than variable names.
  For example, below we can use expression interpolation to
  embed for some readable inline math:        
`
```
Edit: Comme mentionné dans les commentaires, vous avez probablement besoin de chercher l': const oneLine = require('common-tags/lib/oneLine') numéro de série de votre résultat souhaité.

Plus d'infos sur la dite commune-les balises de lien ainsi que sur ce blog

+1 pour la bibliothèque et de mentionner l'ES6 balises. Dans ce cas, cependant, je pense que l'OP aurait besoin de la oneLine une balise à partir de la common-tags de la bibliothèque.
L'exécution d'une exécution de la fonction de formatage de code... Downvote. Bien que la lib est assez utile, et merci pour le partage; pour ce cas d'utilisation, il déclare qu'il "construit à l'aide de la chaîne de es6 modèle", compilation.. impact sur les Performances ?

OriginalL'auteur
12

Personnellement, je préfère le look de joindre un tableau plutôt:
```
var string = [
  `As all string substitutions in Template Strings are JavaScript`,
  `expressions, we can substitute a lot more than variable names.`,
  `For example, below we can use expression interpolation to`,
  `embed for some readable inline math:`
].join(' ');
```
Cette méthode est également plus rapide que les concaténations de l'aide +, car cela ne crée qu'un interne StringBuilder pour l'ensemble au lieu d'une seule pour chaque association (si c'est un micro-optimisation)
L'exécution d'une exécution de la fonction de formatage de code... Downvote. L'impact sur les performances ?
les performances sont vraiment va entraver l'expérience de l'utilisateur, au point que la lisibilité de ce code garantit un downvote?
Imaginez que pour 10000 chaînes que vous avez votre réponse
Orthographier différemment, c'est plus comme un "concept-hérésie", la pratique en elle-même, que je suis en pointant du doigt. C'est definaly conceptualy une mauvaise pratique, et l'on pourrait tout simplement apprendre à utiliser les bons outils pour la bonne chose. IDE de configuration pour "ce qu'ils voient comme un développeur", transpilers et pré-processeurs à faire au moment de la construction fin des choses, et de laisser d'exécution pour l', bien.. au moment de l'exécution des trucs.

OriginalL'auteur
2
- Configurer l'IDE de faire des enveloppements et utiliser un modèle de chaîne 1-liner, comme dans votre 1er extrait de code.
- Utiliser \ échapper littérale char juste avant les sauts de ligne.
  
  Exemple:
```
const string = `1st line\
2nd line\ 
3rd line`; 
```
  Mais il ne vous sauvera pas de problèmes avec l'espace de l'alignement.
- Soit utiliser de la vieille école ES5 concaténation avec un '+'.
  
  Exemple:
```
const string = '1st line' + 
               '2nd line' + 
               '3rd line'; 
```
- Soit utiliser le hack avec le modèle de chaîne vide var ${"}:
  
  Exemple:
```
const string = `1st line${'' 
               }2nd line${'' 
               }3rd line`;
```
La 1ère méthode est beaucoup mieux, en cause:
- moins de symboles (la taille de l'aspect)
- aucune exécution (performance)
C'est le plus intelligent de réponse ici. Allez accepter celle-ci

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.