Pourquoi utiliser CONCATENATE vs & dans Excel?

J'ai remarqué que cela "EXEC MySproc," & "arg, " & "arg2"revient essentiellement à =CONCATENATE("EXEC MySproc,", "arg,", "arg2") inclure la possibilité d'utiliser des évaluations, des fonctions etecetera. Quel est le cas d'utilisation pour utiliser =CONCATENATE()vs &?

C'est pour les gens qui aiment taper plus. Probablement le même public qui fait des choses comme =Sum((A1*A2)-A3)au lieu de =(A1*A2)-A3. (Oui, ces personnes existent et je ne sais pas pourquoi elles le font)

Il offre également de merveilleuses opportunités pour créer votre toute première fonction définie par l'utilisateur avec VBA afin de créer quelque chose de plus utile que Concatenate ().

Excel 2016 (avec un abonnement Office 365) a une nouvelle fonction appelée TextJoin () , qui utilise un délimiteur et une plage comme arguments et qui est beaucoup plus rapide que la saisie des esperluettes et des délimiteurs sous forme de chaînes de texte. Maintenant, cela est utile.

C'est probablement parce qu'ils utilisent le bouton Insérer une fonction.

Je fais parfois cela quand je mange avec la main gauche et que je fais juste quelques formules à bas niveau, ou quand j'utilise un appareil tactile et que je ne pouvais pas être dérangé pour basculer entre les symboles, les lettres et les chiffres sur l'écran tactile. .

Il n'y a que des raisons historiques et de compatibilité. Les anciennes versions d'Excel ne prenaient pas en charge un format et les autres outils de tableurs (tels que Google Docs, Apple Numbers ou Open Office) ne prenaient pas en charge l'autre.

Choisissez celui que vous préférez.

Notez que, selon votre format de sauvegarde, Excel nécessite plus d’espace de sauvegarde CONCATENATE()que &.

À mon avis, l'utilisation sélective de concaténation et d' esperluettes peut conduire à des formules plus claires.

Cette concaténation des détails d'adresse, utilisant un mélange de CONCATENATEet& me semble plus claire:

=CONCATENATE(StreetNumber," ",StreetName," ",StreetType) & CHAR(10) & CONCATENATE(CityName," ",StateCode," ",ZipCode) & CHAR(10) & CountryName

Que l' usage exclusif de &:

=StreetNumber & " " & StreetName & " " & StreetType & CHAR(10) & CityName & " " & StateCode & " " & ZipCode & CHAR(10) & CountryName

Et l'usage exclusif deCONCATENATE

=CONCATENATE(StreetNumber," ",StreetName," ",StreetType,CHAR(10),CityName," ",StateCode," ",ZipCode,CHAR(10),CountryName)

Encore une fois, je dirais qu’un type de fichier UDF BuildAddressserait une meilleure solution (et serait mieux placé pour gérer les subtilités du formatage des adresses dans les domaines d’internationalisation - bien que je ne l’aie pas encore implémentée) ...

Public Function BuildAddress(ByVal StreetNumber As String, ByVal StreetName As String, _
    ByVal StreetType As String, ByVal CityName As String, ByVal StateCode As String, _
    ByVal ZipCode As String, ByVal CountryName As String) As String


    BuildAddress = StreetNumber & " " & StreetName & " " & StreetType & vbCrLf & _
                   CityName & " " & StateCode & " " & ZipCode & vbCrLf & _
                   CountryName

End Function

Mais peut-être un autre exemple, qui inclut l'utilisation de & dans le littéral de chaîne, démontre mieux la difficulté de lire une formule qui s'oblige à utiliser exclusivement des opérateurs:

=A1&"A2&A3&A4"&A5

Pourrait être mieux écrit comme:

=CONCATENATE(A1,"A2&A3&A4",A5)

Mais la performance ce qui compte, . Selon le nombre d’arguments concaténés et la longueur de chaque argument, la CONCATENATEfonction semble surperformer l’opérateur de concaténation d’un facteur compris entre 4 et 6. Certes, cet exemple est extrême, avec 255 arguments étant concaténés, 10 000 fois. Je ne recommande pas d'utiliser une longueur d'argument supérieure à 32, sinon vous risquez de manquer de mémoire / de bloquer Excel.

Voici un mécanisme de synchronisation grossier:

Option Explicit

Const ConcatenationOperatorFormula As String = _
  "=$A$1&$A$2&$A$3&$A$4&$A$5&$A$6&$A$7&$A$8&$A$9&$A$10&$A$11&$A$12&$A$13&$A$14&$A$15&$A$16&$A$17&$A$18&$A$19&$A$20&$A$21&$A$22&$A$23&$A$24&$A$25&$A$26&$A$27&$A$28&$A$29&$A$30&$A$31&$A$32&$A$33&$A$34&$A$35&$A$36&$A$37&$A$38&$A$39&$A$40&$A$41&$A$42&$A$43&$A$44&$A$45&$A$46&$A$47&$A$48&$A$49&$A$50&$A$51&$A$52&$A$53&$A$54&$A$55&$A$56&$A$57&$A$58&$A$59&$A$60&$A$61&$A$62&$A$63&$A$64&$A$65&$A$66&$A$67&$A$68&$A$69&$A$70&$A$71&$A$72&$A$73&$A$74&$A$75&$A$76&$A$77&$A$78&$A$79&$A$80&$A$81&$A$82&$A$83&$A$84&$A$85&$A$86&$A$87&$A$88&$A$89&$A$90&$A$91&$A$92&$A$93&$A$94&$A$95&$A$96&$A$97&$A$98&$A$99&$A$100&" & _
  "$A$101&$A$102&$A$103&$A$104&$A$105&$A$106&$A$107&$A$108&$A$109&$A$110&$A$111&$A$112&$A$113&$A$114&$A$115&$A$116&$A$117&$A$118&$A$119&$A$120&$A$121&$A$122&$A$123&$A$124&$A$125&$A$126&$A$127&$A$128&$A$129&$A$130&$A$131&$A$132&$A$133&$A$134&$A$135&$A$136&$A$137&$A$138&$A$139&$A$140&$A$141&$A$142&$A$143&$A$144&$A$145&$A$146&$A$147&$A$148&$A$149&$A$150&$A$151&$A$152&$A$153&$A$154&$A$155&$A$156&$A$157&$A$158&$A$159&$A$160&$A$161&$A$162&$A$163&$A$164&$A$165&$A$166&$A$167&$A$168&$A$169&$A$170&$A$171&$A$172&$A$173&$A$174&$A$175&$A$176&$A$177&$A$178&$A$179&$A$180&$A$181&$A$182&$A$183&$A$184&$A$185&$A$186&$A$187&$A$188&$A$189&$A$190&$A$191&$A$192&$A$193&$A$194&$A$195&$A$196&$A$197&$A$198&$A$199&$A$200&" & _
  "$A$201&$A$202&$A$203&$A$204&$A$205&$A$206&$A$207&$A$208&$A$209&$A$210&$A$211&$A$212&$A$213&$A$214&$A$215&$A$216&$A$217&$A$218&$A$219&$A$220&$A$221&$A$222&$A$223&$A$224&$A$225&$A$226&$A$227&$A$228&$A$229&$A$230&$A$231&$A$232&$A$233&$A$234&$A$235&$A$236&$A$237&$A$238&$A$239&$A$240&$A$241&$A$242&$A$243&$A$244&$A$245&$A$246&$A$247&$A$248&$A$249&$A$250&$A$251&$A$252&$A$253&$A$254&$A$255"

Const ConcatenateFunctionFormula As String = _
  "=CONCATENATE($A$1,$A$2,$A$3,$A$4,$A$5,$A$6,$A$7,$A$8,$A$9,$A$10,$A$11,$A$12,$A$13,$A$14,$A$15,$A$16,$A$17,$A$18,$A$19,$A$20,$A$21,$A$22,$A$23,$A$24,$A$25,$A$26,$A$27,$A$28,$A$29,$A$30,$A$31,$A$32,$A$33,$A$34,$A$35,$A$36,$A$37,$A$38,$A$39,$A$40,$A$41,$A$42,$A$43,$A$44,$A$45,$A$46,$A$47,$A$48,$A$49,$A$50,$A$51,$A$52,$A$53,$A$54,$A$55,$A$56,$A$57,$A$58,$A$59,$A$60,$A$61,$A$62,$A$63,$A$64,$A$65,$A$66,$A$67,$A$68,$A$69,$A$70,$A$71,$A$72,$A$73,$A$74,$A$75,$A$76,$A$77,$A$78,$A$79,$A$80,$A$81,$A$82,$A$83,$A$84,$A$85,$A$86,$A$87,$A$88,$A$89,$A$90,$A$91,$A$92,$A$93,$A$94,$A$95,$A$96,$A$97,$A$98,$A$99,$A$100," & _
  "$A$101,$A$102,$A$103,$A$104,$A$105,$A$106,$A$107,$A$108,$A$109,$A$110,$A$111,$A$112,$A$113,$A$114,$A$115,$A$116,$A$117,$A$118,$A$119,$A$120,$A$121,$A$122,$A$123,$A$124,$A$125,$A$126,$A$127,$A$128,$A$129,$A$130,$A$131,$A$132,$A$133,$A$134,$A$135,$A$136,$A$137,$A$138,$A$139,$A$140,$A$141,$A$142,$A$143,$A$144,$A$145,$A$146,$A$147,$A$148,$A$149,$A$150,$A$151,$A$152,$A$153,$A$154,$A$155,$A$156,$A$157,$A$158,$A$159,$A$160,$A$161,$A$162,$A$163,$A$164,$A$165,$A$166,$A$167,$A$168,$A$169,$A$170,$A$171,$A$172,$A$173,$A$174,$A$175,$A$176,$A$177,$A$178,$A$179,$A$180,$A$181,$A$182,$A$183,$A$184,$A$185,$A$186,$A$187,$A$188,$A$189,$A$190,$A$191,$A$192,$A$193,$A$194,$A$195,$A$196,$A$197,$A$198,$A$199,$A$200," & _
  "$A$201,$A$202,$A$203,$A$204,$A$205,$A$206,$A$207,$A$208,$A$209,$A$210,$A$211,$A$212,$A$213,$A$214,$A$215,$A$216,$A$217,$A$218,$A$219,$A$220,$A$221,$A$222,$A$223,$A$224,$A$225,$A$226,$A$227,$A$228,$A$229,$A$230,$A$231,$A$232,$A$233,$A$234,$A$235,$A$236,$A$237,$A$238,$A$239,$A$240,$A$241,$A$242,$A$243,$A$244,$A$245,$A$246,$A$247,$A$248,$A$249,$A$250,$A$251,$A$252,$A$253,$A$254,$A$255)"

Const ARGUMENT_STRING_LENGTH As Long = 1

Sub test2()

  Dim start As Single

  'Disable app events to exclude UI/calculation artefacts
  Application.ScreenUpdating = False
  Application.EnableEvents = False
  Application.Calculation = xlCalculationManual

  Dim inputs As Range
  Set inputs = Range("A1:A255")

  Dim operatorRange As Range
  Set operatorRange = Range("B1:B10000")

  Dim functionRange As Range
  Set functionRange = Range("C1:C10000")

  'Reset the range values/formulas
  inputs.Value2 = ""
  operatorRange.Formula = ConcatenationOperatorFormula
  functionRange.Formula = ConcatenateFunctionFormula

  'Change the inputs to invalidate the calculation results
  inputs.Value2 = String(ARGUMENT_STRING_LENGTH, "B")

  'Time the calculation of operator formulas
  start = Timer
  operatorRange.Calculate
  Debug.Print "Operator Calculation", ARGUMENT_STRING_LENGTH, FormatNumber(Timer - start, 8)

  'Time the calculation of function formulas
  start = Timer
  functionRange.Calculate
  Debug.Print "Function Calculation", ARGUMENT_STRING_LENGTH, FormatNumber(Timer - start, 8)

  'Reset the range values to empty
  inputs.Value2 = ""
  operatorRange.Value2 = vbNullString
  functionRange.Value2 = vbNullString

  'Restore App defaults
  Application.ScreenUpdating = True
  Application.EnableEvents = True
  Application.Calculation = xlCalculationAutomatic

End Sub

Et les résultats, en fonction de la longueur des chaînes d'argument:

Method                 String Length   Seconds
---------------------  --------------  -----------
Function Calculation   1               0.06640625
Operator Calculation   1               0.21484380
Function Calculation   10              0.09765625
Operator Calculation   10              0.47265630
Function Calculation   32              0.17578130
Operator Calculation   32              1.17968800

Mais alors, nous n'avons même pas discuté de l'éléphant dans la pièce. Vous construisez une commande SQL en utilisant la concaténation. Ne fais pas ça. Vous exécutez une procédure stockée qui accepte les paramètres. À moins que vous n'ayez désinfecté vos entrées (et j'imagine que vous ne l'avez pas fait), créer une chaîne SQL à l'aide de la concaténation demande une attaque par injection SQL. Vous pourriez aussi bien exposer un fichier UDF appelé JohnnyDropTables...

C'est une différence de domaine sémantique. Concaténer est le nom d'une fonction de feuille de calcul. L'esperluette est un opérateur de concaténation emprunté à Visual Basic. Les personnes qui n'ouvrent jamais utilisent VBA trouveraient une fonction beaucoup plus facile à utiliser que la syntaxe VBA. C'est la même raison pour laquelle il existe un raccourci clavier, une icône et une option de menu pour enregistrer, ce qui facilite l'utilisation du logiciel.

J'utilise les deux.

Pour les longues listes que je devrais peut-être examiner visuellement, une virgule occupe moins d'espace pour les yeux qu'une esperluette.

Il est plus facile de lire une liste de cellules séparées par des virgules que par des esperluettes, d’autant plus qu’une esperluette ressemble trop (après 15 heures par jour) à un $.

Cela donne un rôle significatif à CONCATENATE.

Mais, d'accord, il n'y a pas d'avantage en termes de vitesse, ni de différence fonctionnelle.

Un cas d'utilisation particulier est qu'il =CONCATENATE(A1:A10)est beaucoup plus court que =A1&A2&A3&A4&A4&A6&A7&A8&A9&A10. C'est aussi beaucoup plus évidemment correct (en fait, la &version d' exemple comporte une erreur délibérée).

J'ai d'abord essayé cela, mais j'utilisais Excel, qui est en allemand. TEXTKETTEse comporte comme je le décris, mais la documentation montre qu’il s’agit d’une fonction nouvelle, et remplace VERKETTEN(qui sera l’équivalent allemand de CONCATENATE).

Je n'ai pas vu les vraies réponses ici, mais j'ai un aperçu. (pour toute personne susceptible de rechercher cette réponse à l'avenir)

"Concaténer" est une ancienne fonction héritée, qui fait la même chose que "&", "&" a été ajouté ultérieurement pour des raisons de cohérence dans les langages de programmation. Toutefois, "Concatenate" a été remplacé par "Concat" pour prendre en charge les plages. Vous pouvez donc combiner le format A1: A10 sans recourir à un script personnalisé. Le "&" n'autorise toujours pas de plage et ne prend que la première cellule de la même manière que les fonctions "Concaténation". Donc, si vous combinez une plage, le "Concat" donne ce changement de fonction supplémentaire par rapport aux 2 styles précédents qui sont simplement codés différemment. Faire de "Concaténer" et "&" une préférence lorsque vous utilisez des chaînes combinées non comprises dans la plage requise pour la façon dont vous aimez le taper.

https://support.office.com/en-ie/article/concat-function-9b1a9a3f-94ff-41af-9736-694cbd6b4ca2

RTFM Microsoft dit utiliser le& .

BTW, vous obtiendrez des réponses différentes lorsque vous utiliserez l’opérateur SUM.