Vraag Verschillen tussen lodash en onderstrepingsteken


Waarom zou iemand de voorkeur geven aan de lodash.js of underscore.js bibliotheek over de andere?

Lodash lijkt een vervangende onderlaag te zijn voor een onderstrepingsteken, waarbij de laatste al langer bestaat.

Ik vind beide briljant, maar ik weet niet genoeg over hoe ze werken om een ​​goede vergelijking te maken, en ik zou graag meer willen weten over de verschillen.


1400
2017-12-09 17:08


oorsprong


antwoorden:


Ik heb Lo-Dash gemaakt om meer consistente ondersteuning voor iteratie van verschillende omgevingen te bieden voor arrays, strings, objecten en arguments voorwerpen1. Het is sindsdien een superset geworden van Underscore, dat zorgt voor consistenter API-gedrag, meer Kenmerken (zoals AMD-ondersteuning, deep clone en deep merge), grondiger documentatie en unit tests (tests die worden uitgevoerd in Node, Ringo, Rhino, Narwhal, PhantomJS en browsers), betere algehele prestaties en optimalisaties voor grote arrays / object iteratie, en meer flexibiliteit met op maat gemaakte builds en sjabloon pre-compilatie hulpprogramma's.

Omdat Lo-Dash vaker wordt bijgewerkt dan Underscore, a lodash underscore bouwen is voorzien om compatibiliteit met de nieuwste stabiele versie van Underscore te garanderen.

Op een gegeven moment werd ik zelfs gegeven duw toegang onderstrepen, mede omdat Lo-Dash verantwoordelijk is voor het bijeenbrengen van meer dan 30 problemen; landing bug fixes, nieuwe functies en perf winsten in Underscore v1.4.x +.

Daarnaast zijn er ten minste 3 backbone-ketelplaten met standaard Lo-Dash en Lo-Dash wordt nu vermeld in de officiële backbone documentatie.

Bekijk het bericht van Kit Cambridge, Zeg "Hallo" tegen Lo-Dash, voor een diepere analyse van de verschillen tussen Lo-Dash en Underscore.

voetnoten:

  1. Underscore heeft inconsistente ondersteuning voor arrays, strings, objecten en arguments voorwerpen. In recentere browsers worden de onderstreepjesmethoden genegeerd gaten in matrices, "Objecten" -methoden worden herhaald arguments objecten, strings worden behandeld als array-achtig, en methoden correct herhalen functies (het negeren van hun "prototype" eigenschap) en objecten (iterating shadowed properties zoals "toString" en "valueOf"), terwijl dat in oudere browsers niet het geval is. Ook Underscore-methoden zoals _.clone gaten in arrays behouden, terwijl anderen dat leuk vinden _.flatten niet.

1777
2017-12-16 05:34



Lo-Dash is geïnspireerd door een onderstrepingsteken, maar is tegenwoordig een superieure oplossing. U kunt uw maken op maat gemaakte builds, heb een hogere prestaties, steun AMD en heb geweldige extra functies. Controleer dit Lo-Dash vs Underscore benchmarks op jsperf en .. dit geweldige post over lo-dash:

Een van de handigste functies wanneer u met verzamelingen werkt, is de syntaxis van steno:

var characters = [
  { 'name': 'barney', 'age': 36, 'blocked': false },
  { 'name': 'fred',   'age': 40, 'blocked': true }
];

// using "_.filter" callback shorthand
_.filter(characters, { 'age': 36 });

// using underscore
_.filter(characters, function(character) { return character.age === 36; } );

// → [{ 'name': 'barney', 'age': 36, 'blocked': false }]

(genomen van lodash docs)


165
2017-12-13 21:51



Naast John's antwoord, en het lezen van lodash (die ik tot nu toe had gezien als een "ik-too" om te onderstrepen), en het zien van de prestatietests, het lezen van de broncode, en Blog berichten, de weinige punten die lodash veel beter maken dan het onderstrepingsteken zijn deze:

  1. Het gaat niet om de snelheid, zoals het gaat consistentie van snelheid (?)

    Als je kijkt naar de broncode van de underscore, zie je in de eerste paar regels dat het onderstrepingsteken terugvalt op de native implementaties van veel functies. Hoewel in een ideale wereld, zou dit een betere benadering zijn geweest, als je kijkt naar enkele van de perf-links die zijn gegeven deze dia's, het is niet moeilijk om de conclusie te trekken dat de kwaliteit van die 'native implementaties' veel van browser-naar-browser varieert. Firefox is verdomd snel in sommige van de functies, en in sommige Chrome domineert. (Ik veronderstel dat er enkele scenario's zouden zijn waar IE ook zou domineren). Ik geloof dat het beter is om de voorkeur te geven aan een code waarvan prestatie is consistenter in browsers.

    Lees de blogpost eerder, en in plaats van het te geloven omwille van jezelf, kun je zelf beoordelen door het benchmarks. Ik ben op dit moment stomverbaasd en zie dat een lodiks 100-150% sneller presteert dan een gelijkwaardig streepje eenvoudig, inheems functies zoals Array.every in Chrome!

  2. De extras in lodash zijn ook heel nuttig.

  3. Wat de opmerkelijke opmerking van Xananax betreft die een bijdrage aan de code van de onderstreepster suggereert: het is altijd beter om te hebben GOED concurrentie, het houdt niet alleen innovatie in stand, maar drijft je ook om jezelf (of je bibliotheek) in goede vorm te houden.

Hier is een lijst van verschillen tussen lodash en zijn underscore-build is een vervangende vervanging voor uw onderstrepingprojecten.


57
2017-08-18 14:18



Als je net als ik een lijst verwachtte met gebruiksverschillen tussen underscore en lodash, is er een gids voor het migreren van onderstrepingsteken naar lodash.

Hier is de huidige staat van het voor het nageslacht:

  • Laag streepje _.compose is Lodash _.flowRight
  • Laag streepje _.contains is Lodash _.includes
  • Laag streepje _.findWhere is Lodash _.find
  • Laag streepje _.invoke is Lodash _.invokeMap
  • Laag streepje _.mapObject is Lodash _.mapValues
  • Laag streepje _.pluck is Lodash _.map
  • Laag streepje _.where is Lodash _.filter
  • Laag streepje _.any is Lodash _.some
  • Laag streepje _.all is Lodash _.every
  • Laag streepje _.each staat niet toe om te vertrekken door terug te keren false
  • Laag streepje _.flatten is standaard diep, terwijl Lodash ondiep is
  • Laag streepje _.isFinite komt niet overeen met Number.isFinite
       (B.v. _.isFinite('1') komt terug true in onderstrepingsteken maar false in   Lodash)
  • Laag streepje _.matches steno ondersteunt geen diepe vergelijkingen
       (B.v. _.filter(objects, { 'a': { 'b': 'c' } }))
  • Onderstrepen ≥ 1,7 en Lodash hebben hun veranderd _.template syntaxis naar
    _.template(string, option)(data)
  • Lodash _.uniq accepteert geen iteratee functioneer als Underscore's. Gebruik Lodash _.uniqBy
  • Lodash _.first en ._last accepteer geen n argument zoals Underscore's. Gebruik slice
  • Lodash _.memoize caches zijn Map zoals objecten
  • Lodash ondersteunt impliciete ketenvorming, lui kettingsysteem & snelkoppeling   fusie
  • Lodash verdeelde zijn overbelaste _.head, _.last, _.rest, & _.initial naar binnen
      _.take, _.takeRight, _.drop, &    _.dropRight
       (d.w.z. _.head(array, 2) in Underscore is    _.take(array, 2) in Lodash)

55
2017-07-21 09:35



Dit is 2014 en een paar jaar te laat. Toch denk ik dat mijn punt geldt:

IMHO deze discussie werd nogal buiten proportie opgeblazen. Het citeren van het bovengenoemde blogpost:

De meeste JavaScript-hulpprogramma's, zoals Underscore, Valentine en   wu, vertrouw op de "native-first dual approach". Deze aanpak geeft de voorkeur   native implementaties, alleen terugvallen op vanilla JavaScript als het   native equivalent wordt niet ondersteund. Maar jsPerf onthulde een interessant   trend: de meest efficiënte manier om een ​​array of array-achtig te itereren   verzameling is om de native implementaties volledig te vermijden, te kiezen voor   eenvoudige loops in plaats daarvan.

Alsof "simple loops" en "vanilla Javascript" meer native zijn dan implementaties van de Array- of Object-methode. Jezus ...

Het zou zeker leuk zijn om een ​​enkele bron van waarheid te hebben, maar dat is niet het geval. Zelfs als je anders is verteld, is er geen Vanilla God, mijn liefste. Het spijt me. De enige veronderstelling die echt geldt, is dat we allemaal Javascript-code schrijven die is bedoeld om goed te presteren in alle belangrijke browsers, wetende dat ze allemaal verschillende implementaties van dezelfde dingen hebben. Het is een trut om het hoofd te bieden, op zijn zachts gezegd. Maar dat is het uitgangspunt, of je het nu leuk vindt of niet.

Misschien werken jullie allemaal aan grootschalige projecten die twitterachtige prestaties vereisen, zodat je echt het verschil kunt zien tussen 850.000 (onderstrepingsteken) versus 2.500.000 (lodash) iteraties over een lijst per sec direct!

Ik ben dat niet. Ik bedoel, ik heb projecten uitgevoerd waarbij ik prestatieproblemen moest aanpakken, maar deze zijn nooit opgelost of veroorzaakt door Underscore en Lo-Dash. En tenzij ik de echte verschillen in uitvoering en prestaties (we hebben het nu over C ++) te pakken krijg, laten we zeggen een lus over een iterabele (object of array, dun of niet!), Ik heb liever geen last van claims op basis van de resultaten van een benchmarkplatform dat is al eigenwijs.

Het heeft slechts één enkele update nodig van laten we zeggen dat Rhino de implementaties van de Array-methode in vuur en vlam zet op een manier die geen enkele "middeleeuwse lusmethode beter en voor altijd doet en zo niet". Priester kan zijn / haar weg redeneren over het simpele feit dat alle een plotselinge array-methoden in FF zijn veel sneller dan zijn / haar eigenwijs hersenkrakende. Man, je kunt gewoon je runtime-omgeving niet bedriegen door je runtime-omgeving te bedriegen! Denk daar eens over bij het promoten van ...

je gereedschapsriem

... de volgende keer.

Dus om het relevant te houden:

  • Gebruik onderstrepingstekens als u van gemak houdt, zonder inheems gedrag op te offeren.
  • Gebruik Lo-Dash als u van gebruiksgemak houdt en van de uitgebreide functiecatalogus (deep-copy enz.) Houdt en als u wanhopig op zoek bent naar directe uitvoeringen en het vooral niet erg vindt om naar een alternatief te streven zodra native API's outshine zijn eigenwijs workaurounds. Wat binnenkort gaat gebeuren. Periode.
  • Er is zelfs een derde oplossing. DIY! Ken uw omgevingen. Weet over inconsistenties. Lees hun (John-Daviden Jeremys) code. Gebruik dit of dat niet zonder in staat te zijn uit te leggen waarom een ​​consistentie / compatibiliteitslaag echt nodig is en verbetert uw workflow of verbetert de prestaties van uw app. Het is zeer waarschijnlijk dat aan uw vereisten is voldaan met een eenvoudige polyfill die u perfect zelf kunt schrijven. Beide bibliotheken zijn gewoon vanille met een beetje suiker. Ze vechten allebei over wie de zoetste taart serveert. Maar geloof me, uiteindelijk koken beiden alleen met water. Er is geen Vanilla God dus er kan geen Vanilla-paus zijn, toch?

Kies de meest geschikte aanpak voor uw behoeften. Zoals gewoonlijk. Ik geef de voorkeur aan fallbacks op daadwerkelijke implementaties ten opzichte van eigenzinnige runtime cheats op elk gewenst moment, maar zelfs dat lijkt tegenwoordig een kwestie van smaak te zijn. Blijf bij kwaliteitsbronnen zoals http://developer.mozilla.com en http://caniuse.com en het komt goed.


43
2017-09-11 21:27



Ik ben het eens met de meeste dingen die hier worden gezegd, maar ik wil alleen wijzen op een argument ten gunste van underscore.js: de grootte van de bibliotheek.

Speciaal in het geval dat u een app of website ontwikkelt die voornamelijk op mobiele apparaten zal worden gebruikt, kan de grootte van de resulterende bundel en het effect op de opstart- of downloadtijd een belangrijke rol spelen.

Ter vergelijking zijn deze groottes die ik heb opgemerkt met source-map-explorer na het uitvoeren van een ionische server:

lodash: 523kB
underscore.js: 51.6kb

14
2018-04-26 14:20



Ik weet niet zeker of dat is wat OP betekende, maar ik kwam deze vraag tegen omdat ik op zoek was naar een lijst met problemen die ik in gedachten moet houden bij het migreren van een onderstrepingsteken naar lodash.

Ik zou het zeer op prijs stellen als iemand een artikel met een volledige lijst van dergelijke verschillen postte. Laat ik beginnen met de dingen die ik op de moeilijke manier heb geleerd (dat wil zeggen dingen die mijn code hebben doen ontploffen tijdens productie: /):

  • _.flatten in underscore is standaard diep en je moet true doorgeven als tweede argument om het ondiep te maken. In lodash is het standaard ondiep en het passeren van waar als tweede argument zal het diep maken! :)
  • _.last in underscore accepteert een tweede argument dat aangeeft hoeveel elementen je wilt. In lodash er is geen dergelijke optie. Je kunt dit emuleren met .slice
  • _.first (zelfde probleem)
  • _.template in underscore kan op vele manieren worden gebruikt, een daarvan is het leveren van de sjabloonkoord en -gegevens en krijgen HTML terug (of althans dat is hoe het een tijd geleden werkte). In lodash u ontvangt een functie die u vervolgens met de gegevens moet voeden.
  • _(something).map(foo) werkt in underscore, maar in lodash moest ik het herschrijven _.map(something,foo). Misschien was dat gewoon een TypeScript-kwestie

9
2018-03-25 12:16