RnVuZGFtZW50ZWxlIGFuYWx5c2UgfCBXZWxrZSB6aWpuIGRlIGJlc3RlIHRvb2xzIHZvb3IgaGV0IGFuYWx5c2VyZW4gdmFuIGhvb2d3YWFyZGlnZSBjcnlwdG9jdXJyZW5jeT8=

2023-02-23, 09:01

<p><img src="https://gimg2.gateimg.com/image/article/1677142480bowen.jpg" alt=""></p>
<h2 id="h2-Te20lang20niet20gelezen675153"><a name="Te lang; niet gelezen" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Te lang; niet gelezen</h2><p>Fundamentele analyse biedt handelaars en beleggers de nodige informatie om verstandige beleggingsbeslissingen te nemen.</p>
<p>De marktkapitalisatie ten opzichte van de gerealiseerde waarde (MVRV), de verhouding tussen de netwerkwaarde en het werkelijke transactievolume op de chain (NVT) en de voorraadflowratio zijn momenteel belangrijke basisindicatoren voor cryptovaluta.</p>
<p>Op dit moment zijn enkele hoogwaardige cryptografie-analysetools die handelaren kunnen gebruiken BaseRank, Crypto Fees, Glassnode Studio, Coinigy, TradingView, Cryptowatch, CoinMarketCal, Coin Metrics en CryptoView.ch.</p>
<p>Handelaren moeten topcryptografie-analysetools en -indicatoren gebruiken omdat cryptocurrencies vaak gepaard gaan met prijsvolatiliteit en met behulp van verschillende tools kunnen mensen een goed inzicht krijgen in het gedrag van de cryptomarkt dat hierdoor wordt beïnvloed.</p>
<h2 id="h2-Inleiding942665"><a name="Inleiding" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Inleiding</h2><p>Handelaren die investeren in cryptocurrency en andere digitale activa moeten leren hoe ze de specifieke prestaties van deze effecten op de markt kunnen analyseren. De meeste cryptoprojecten bieden voldoende informatie aan gebruikers via whitepapers, gemeenschappen en websites, zodat investeerders weloverwogen investeringsbeslissingen kunnen nemen. Investeerders gebruiken meestal kwantitatieve en kwalitatieve methoden om het ontwikkelingspotentieel van cryptocurrency te evalueren. Dit artikel zal uitleggen hoe investeerders fundamentele analyse gebruiken om de waarde van cryptocurrency te beoordelen.</p>
<h2 id="h2-Wat20is20fundamentele20analyse239913"><a name="Wat is fundamentele analyse?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is fundamentele analyse?</h2><p>Fundamentele analyse is een proces om de intrinsieke waarde van cryptocurrency te evalueren, om te bepalen of cryptocurrency overgewaardeerd of ondergewaardeerd is. Met andere woorden, fundamentele analyse is een methode om de werkelijke waarde van een activum te bepalen, inclusief een analyse van zowel interne als externe factoren die van invloed zijn op de activaprijs.</p>
<p>Cryptobeoordelaars gebruiken cryptogeldanalysetools om de werkelijke waarde van deze digitale activa te bepalen. Enkele populaire cryptotechnische analyse-instrumenten zijn momenteel de marktkapitalisatie ten opzichte van de realised value (MVRV), het netwerkkapitaal ten opzichte van de werkelijke on-chain transactievolume (NVT) en de voorraadstroomverhouding. Deze on-chain indicatoren kunnen worden gebruikt om de werkelijke stemming op de cryptomarkt te meten.</p>
<h2 id="h2-Belangrijke20fundamentele20analyse20FA20indicatoren983029"><a name="Belangrijke fundamentele analyse (FA) indicatoren" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Belangrijke fundamentele analyse (FA) indicatoren</h2><p>Zoals eerder vermeld, zullen cryptofundamentalanalisten cryptografische analyses gebruiken om deze digitale activa te analyseren. Deze indicatoren stellen ons in staat om de marktbewegingen van cryptovaluta te begrijpen voordat we ze kopen. Hieronder worden de verhouding tussen marktwaarde en gerealiseerde waarde (MVRV), de verhouding tussen netwerkwaarde en werkelijke on-chain transactievolume (NVT) en de voorraadstroomratio toegelicht.</p>
<h3 id="h3-Verhouding20tussen20marktwaarde20en20gerealiseerde20waarde20MVRV746635"><a name="Verhouding tussen marktwaarde en gerealiseerde waarde (MVRV)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Verhouding tussen marktwaarde en gerealiseerde waarde (MVRV)</h3><p>De verhouding tussen marktkapitalisatie en gerealiseerde waarde verwijst naar de verhouding tussen de marktkapitalisatie van cryptocurrency en de gerealiseerde waarde ervan. Gewoonlijk wordt de marktkapitalisatie berekend door de totale circulerende aanbod van een bepaald activum te vermenigvuldigen met de huidige marktprijs ervan.</p>
<p>Aan de andere kant wordt de gerealiseerde waarde berekend door elke munt te vermenigvuldigen met de prijs op het moment van de laatste verplaatsing. Bovendien kan geschikte data zoals de UTXO-technologie van <a href="/price/bitcoin-btc" target="_blank" class="blog_inner_link">Bitcoin</a> worden gebruikt om de gerealiseerde waarde te berekenen. Deze gerealiseerde waarde, ook wel gerealiseerde kapitalisatie genoemd, is een betere manier om de waarde van cryptocurrency te meten, omdat het de werkelijke prijs van elke munt op het moment van verplaatsing gebruikt.</p>
<p>MVRV = marktkapitalisatie / gerealiseerde marktkapitalisatie</p>
<p>Als de MVRV hoger is dan 1, betekent dit dat de waarde van de cryptocurrency overgewaardeerd is.</p>
<p>Over het algemeen, als de MVRV-waarde hoog is, geeft dit aan dat de huidige marktprijs hoger is dan de waarde van de cryptomunt op het moment van aankoop door investeerders, wat erop wijst dat investeerders de munten of tokens op korte termijn kunnen verkopen om winst te maken. Daarentegen, als de MVRV-waarde laag is, geeft dit aan dat investeerders waarschijnlijk de munt zullen vasthouden en wachten tot de waarde ervan stijgt.</p>
<h3 id="h3-De20verhouding20tussen20de20netto20waarde20en20de20werkelijke20transactiehoeveelheid20op20de20blockchain20NVT31995"><a name="De verhouding tussen de netto waarde en de werkelijke transactiehoeveelheid op de blockchain (NVT)" class="reference-link"></a><span class="header-link octicon octicon-link"></span>De verhouding tussen de netto waarde en de werkelijke transactiehoeveelheid op de blockchain (NVT)</h3><p>Natuurlijk is de verhouding tussen de waarde van het netwerk en de werkelijke transactieomvang op de blockchain (NVT) ook een praktische indicator voor cryptotransacties. Deze analyse-instrumenten op de blockchain zijn vergelijkbaar met de prijs-winstverhouding (P/E) die wordt gebruikt in de traditionele financiële sector bij het verwerken van aandelen.</p>
<p>We berekenen meestal de NVT-ratio door de marktwaarde van activa te delen door het dagelijkse handelsvolume dat de intrinsieke waarde van de cryptocurrency weerspiegelt. Deze indicator heeft verschillende effecten op handelaren en andere investeerders.</p>
<p>Bijvoorbeeld, als de prijs van de cryptocurrency blijft stijgen zonder handelsvolumeondersteuning, kan de valuta in een bubbelgebied terechtkomen. In brede zin kan er een prijsbubbel optreden als de NTV-verhouding 90-95 of hoger is. Dit komt omdat de prijs van de valuta stijgt, terwijl de intrinsieke waarde niet verandert.</p>
<p>Als de prijs stabiel blijft maar de handelsvolume toeneemt, geeft dit aan dat dit het moment is om te kopen. Een lage NVT-ratio geeft aan dat het vermogen ondergewaardeerd is en een bearish momentum laat zien. Aan de andere kant, als de NVT-ratio constant blijft, geeft dit aan dat er een evenwicht is tussen de groei van het vermogen en de hoeveelheid overdracht ervan.</p>
<h3 id="h3-Voorraadomzet984810"><a name="Voorraadomzet" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voorraadomzet</h3><p>De voorraadliquiditeitsratio is een andere topcryptografische analysetool die handelaren helpt begrijpen hoe ze cryptoprijzen moeten interpreteren. Dit is echter een indicator voor cryptografische valuta’s met een beperkte voorraad, zoals bitcoin. Het beschouwt deze cryptografische valuta als een vaste schaarse hulpbron, vergelijkbaar met kostbare mineralen zoals goud en diamanten.</p>
<p>De voorraadomzetverhouding laat zien hoe de nieuwe toevoer van een activum gedurende een bepaalde periode (zoals een jaar) is veranderd en geeft aan hoe lang het duurt om de huidige cyclusvoorziening te produceren.</p>
<p>Bitcoin is een typisch voorbeeld van een beperkte voorraad, met een vaste voorraad van 21 miljoen munten. We kunnen de voorraadstroomratio berekenen door de circulerende voorraad te delen door de totale productie binnen een jaar. Voor Bitcoin kunnen we de jaarlijkse productie berekenen door het aantal nieuw gedolven bitcoins te gebruiken. We kunnen de voorraadstroomratio van Bitcoin berekenen met de volgende formule.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16771427589931677142614_.pic.jpg" alt=""></p>
<p>Als de geschatte circulerende voorraad 19.000 is, is de jaarlijkse uitstoot ongeveer 328.500.</p>
<p>Dus de S2F-waarde van Bitcoin = 19.000.000/328.500 = 57,84</p>
<p>Een hoge prijs duidt op een zeer schaars goed. Bijvoorbeeld, de S2F-waarde van Bitcoin geeft aan dat het produceren van 19 miljoen Bitcoins op de huidige productiesnelheid 57,84 jaar zou duren. Echter, Bitcoin zal geen constante voorraadverhouding hebben, omdat elke keer dat een miner 21.000 Bitcoins aan de blockchain toevoegt, er een halvering van de Bitcoins plaatsvindt. Over het algemeen vindt ongeveer elke 4 jaar een halvering van Bitcoin plaats. Analisten voorspellen dat er in 2140 opnieuw 21.000 Bitcoins zullen worden geproduceerd als gevolg van de halvering.</p>
<h2 id="h2-Voorbeelden20van20fundamentele20analyse20tools930659"><a name="Voorbeelden van fundamentele analyse tools" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Voorbeelden van fundamentele analyse tools</h2><p>In plaats van handmatig belangrijke fundamentele analyse-indicatoren te berekenen, is het beter om gebruik te maken van websites die deze indicatoren publiceren. Enkele goede websites voor fundamentele analyse zijn Baserank, Glassnode Studio, Coinigy, CoinMarketCal, Coin Metrics, Cryptovew.ch en TradingView.</p>
<p>BaseRank: BaseRank is een van de grootste gidsen voor het investeren in cryptovaluta, omdat het statistische gegevens en opmerkingen van talrijke professionals in het crypto-veld, zoals investeerders en experts, samenvat. Het biedt praktische informatie over het team, investeringsrisico’s en asset-gebruik. Bovendien biedt het ook een ranking van 0 tot 100 voor cryptovaluta om investeerders te begeleiden bij het nemen van investeringsbeslissingen.</p>
<p>Crypto Vergoedingen: Deze website biedt een overzicht van de transactiekosten voor verschillende cryptocurrency’s in de afgelopen 24 uur en 7 dagen. Zoals we weten, is de gasvergoeding van het netwerk een duidelijke indicator van de vraag naar cryptocurrency. Relatief hoge transactiekosten duiden vaak op een hoge vraag naar het betreffende actief.</p>
<p>Glassnode Studio: De meeste handelaren en investeerders maken gebruik van Glassnode Studio omdat het een verzameling is van fundamentele gegevens van verschillende bronnen, waaronder transactie- en mijnbouwgegevens, portefeuilleposities en prijsinformatie. Hierdoor kunnen gebruikers toegang krijgen tot verschillende soorten analytische informatie en deze gebruiken voor handelsdoeleinden en investeringsbeslissingen.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16771427839941677142658_.pic.jpg" alt=""><br>Glassnode Producten - Glassnode</p>
<p>Coinigy: Met Coinigy kunt u een enkele interface maken met behulp van API’s van verschillende beurzen om verschillende portefeuilles en beursrekeningen te combineren. Hiermee kunt u meer dan 40 cryptohandelplatforms, waaronder beurzen, integreren. Bovendien kan het u helpen handelen op verschillende handelsplatforms en gebruik maken van cryptografische grafiekanalyse.</p>
<p>Trading View: Hoewel handelaren toegang kunnen krijgen tot de gegevensgrafieken die ze willen zien via een betaald abonnement, kunnen ze ook gratis toegang krijgen tot cryptografische grafiekindicatoren. Naast het profiteren van de grafieken, kunnen beleggers ook echte marktbewegingen zien en andere functies gebruiken. Handelaren en andere beleggers kunnen informatie uitwisselen op het forum en live video’s van experts en analisten bekijken. Over het algemeen kan de Trading View-community de meeste gebruikers helpen om essentiële handelsvaardigheden en kennis te verwerven.</p>
<p>Cryptowat.ch: Beleggers kunnen marktinformatie verkrijgen van meer dan 24 belangrijke beurzen, inclusief handelsgrafieken. Het consolideert ook talrijke gegevens van meer dan 4000 online markten.</p>
<p>CoinMarketCal: Investeerders moeten voorafgaand aan het investeren in cryptocurrency enige informatie kennen. Bijvoorbeeld, ze moeten op de hoogte zijn van trendnieuws dat de prijs van cryptocurrency beïnvloedt, en dat is waar CoinMarketCal van pas komt. Het biedt gebruikers belangrijk nieuws en informatie om hen te helpen bij het nemen van belangrijke handelsbeslissingen. Gebruikers kunnen ook opmerkingen plaatsen bij sommige van deze informatie.</p>
<p><img src="https://gimg2.gateimg.com/image/article/16771428169951677142678_.pic.jpg" alt=""><br>CoinMarketCal-producten - Coincloak</p>
<p>Coin Metrics: Coin Metrics is een cryptografische analyse tool die zowel on-chain als off-chain ondersteunt en onderzoekers en analisten in staat stelt om het gedrag en de prestaties van de cryptomarkt te begrijpen. Het heeft enkele functies voor de visualisatie van trends. Het biedt ook verschillende indicatoren en indices om de laatste ontwikkelingen en trends in de markt weer te geven.</p>
<p>CryptoView.ch: De belangrijkste functie van CryptoView is om de cryptomunten weer te geven die worden verhandeld op cryptobeurzen, de locaties van cold storage en de cryptomunten in digitale portefeuilles van derden. Het biedt zowel kwantitatieve als kwalitatieve gegevens van vele beurzen, waardoor investeerders inzicht kunnen krijgen in de laatste ontwikkelingen in de sector.</p>
<h2 id="h2-Slotwoord135333"><a name="Slotwoord" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Slotwoord</h2><p>Handelaren en investeerders moeten de basisprincipes van handel begrijpen, evenals hoe ze cryptoprijzen moeten interpreteren, om te investeren in winstgevende blockchainprojecten en cryptocurrencies. Daarnaast zijn er tal van cryptanalysetools en cryptohandelindicatoren die beleggers kunnen gebruiken om fundamentele en diepgaande kennis over investeringen te verkrijgen.</p>
<h2 id="h2-Veelgestelde20vragen20over20fundamentele20analyse631540"><a name="Veelgestelde vragen over fundamentele analyse" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Veelgestelde vragen over fundamentele analyse</h2><h3 id="h3-Wat20moet20ik20doen20voordat20ik20cryptocurrency20koop407779"><a name="Wat moet ik doen voordat ik cryptocurrency koop?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat moet ik doen voordat ik cryptocurrency koop?</h3><p>Voordat u investeert in cryptocurrency, moeten beleggers een paar dingen vooraf doen. Bijvoorbeeld, het zorgvuldig lezen en begrijpen van het bijbehorende project whitepaper, het beoordelen van sociale mediakanalen en hun reputatie, en tegelijkertijd het onderzoeken van de prijsgeschiedenis van het betrokken project. Bovendien is het ook belangrijk voor handelaren om de prestaties te analyseren door verschillende indicatoren te combineren, zoals marktkapitalisatie, handelsvolume en aanbod.</p>
<h3 id="h3-Welke20populaire20indicatoren20zijn20er20momenteel20in20cryptohandel334615"><a name="Welke populaire indicatoren zijn er momenteel in cryptohandel?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke populaire indicatoren zijn er momenteel in cryptohandel?</h3><p>Handelaren kunnen verschillende technische analyse-indicatoren combineren om de prestaties van cryptocurrency-prijzen te evalueren. Enkele van de populairste indicatoren zijn onder andere de voortschrijdend gemiddelde, handelsvolume, de stochastische indicator, de relatieve sterkte-index (RSI) en de Bollinger Bands-indicator. Het wordt aanbevolen voor handelaren om zowel achterlopende indicatoren als leidende indicatoren te combineren om betrouwbare beslissingen te nemen. <a href="/price-prediction" rel="nofollow noopener noreferrer" target="_blank">Prijsvoorspelling</a>.</p>
<h3 id="h3-Welke20hoogwaardige20websites20kunnen20worden20gebruikt20bij20het20uitvoeren20van20fundamentele20analyse720884"><a name="Welke hoogwaardige websites kunnen worden gebruikt bij het uitvoeren van fundamentele analyse?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke hoogwaardige websites kunnen worden gebruikt bij het uitvoeren van fundamentele analyse?</h3><p>Op dit moment zijn er tal van websites die gegevens van verschillende bronnen verzamelen, waarmee we redelijke handelsbeslissingen kunnen nemen. Wat betreft fundamentele analyse, zijn momenteel de beste websites BaseRank, Crypto Fees, Glassnode Studio, Coinigy, TradingView, Cryptowatch, CoinMarketCal, Coin Metrics en CryptoView.ch. De meeste van deze websites bevatten verschillende soorten gegevens, zoals grafieken en grafieken, die handelaren de beste en meest complete informatie kunnen bieden.</p>
<h3 id="h3-Wat20is20de20vorm20van20cryptocurrency343251"><a name="Wat is de vorm van cryptocurrency?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Wat is de vorm van cryptocurrency?</h3><p>Cryptocurrency verwijst naar een soort digitaal actief dat beschermd wordt door cryptografische technologie. Mensen kunnen dit soort valuta niet dubbel uitgeven of valse valuta maken. We kunnen cryptocurrency als een andere betaalmethode beschouwen, omdat het veilig kan worden overgedragen aan anderen. Bitcoin is de eerste cryptocurrency en op basis van marktkapitalisatie is Bitcoin de topmunt. Andere populaire cryptocurrencies zijn onder meer ETH, … <a href="/price/tether-usdt" rel="nofollow noopener noreferrer" target="_blank">Tether</a> USDT、Binance Munt ( <a href="/price/bnb-bnb" rel="nofollow noopener noreferrer" target="_blank">BNB</a>)、 <a href="/price/cardano-ada" rel="nofollow noopener noreferrer" target="_blank">Cardano</a>、 <a href="/price/tron-trx" rel="nofollow noopener noreferrer" target="_blank">TRON</a> en <a href="/price/xrp-xrp" rel="nofollow noopener noreferrer" target="_blank">XRP</a> Wachten.</p>
<h3 id="h3-Welke20problemen20moeten20nog20worden20opgelost20met20cryptocurrency450270"><a name="Welke problemen moeten nog worden opgelost met cryptocurrency?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Welke problemen moeten nog worden opgelost met cryptocurrency?</h3><p>Het belangrijkste probleem van de meeste cryptocurrencies is de prijsvolatiliteit. Over het algemeen kan de prijs van cryptocurrencies sterk dalen en stijgen op korte termijn. Bovendien kunnen mensen cryptocurrencies verliezen als gevolg van hacks, verlies van privésleutels en zaadzinnen.</p>
<div class="blog-details-info"><br>  <div>Auteur:<strong>Mashell C.</strong>Gate.io researcher<div>Vertaler: Joy Z.<div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de auteur en vormt geen enkel handelsadvies.<br>  </em><div><em></em>本文内容为原创，版权为Gate.io所有，如需转载请注明作者和出处，否则将追究法律责任。<br></div><p></p><br></div></div></div></div>