Açıklama

Math.random () yöntemi bir sözde döndürür rastgele sayı 0 ile 1 arasında.

0 (dahil) ile 1 (hariç) aralığında bir sözde rasgele sayı oluşturulur, yani döndürülen sayı sıfır olabilir, ancak her zaman birden küçük olacaktır.

Bir kayan noktalı sayıyı bir tam sayıya yuvarlamak için, örneğin Math.floor () yöntemini kullanabilirsiniz.

Sözdizimi

Matematik.rastgele ()

Geri dönüş değeri

• Kayan nokta numarası 0 (dahil) ile 1 (hariç) arasında değişir.

Math.random () yöntemi esas olarak belirli bir aralıkta sözde rasgele bir sayı üretmek için kullanılır. Örneğin, 50 ile 100 (dahil) aralığında bir sayı almamız gerekiyor. Bunu yapmak için aşağıdaki kodu yazmalıyız:

Document.write (Math.floor (Math.random () * 51 + 50));

Örneğimizin nasıl çalıştığına ve bu özel formun neden kullanıldığına daha yakından bakalım. Her şeyden önce, istenen aralıktan elde edilen minimum değeri belirtmemiz gerekiyor, örneğimizde bu 50 sayısıdır. Şimdi bir şekilde 50 sayısına eklendiğinde toplamı olmayacak rastgele bir sayı almamız gerekiyor. sayı 100. Matematikten bildiğimiz gibi, bilinmeyen terimi toplamdan bilinen terim çıkarılarak bulunur. 100 - 50: 50'lik bir fark elde ederiz. Şimdi bu sayının bize uygun olup olmadığını kontrol etmek için mümkün olan minimum ile çarpıyoruz ve azami sayı Math.random () yöntemiyle döndürülür. Minimum 0,004704564176082244 * 50 = 0,2 ... ve maksimum 0,999999999999746223 * 50 = 49,9 ... Ve böylece farkı olası maksimum rasgele sayı ile çarptığımızda sonucun bize bir sayının tamsayı kısmını verdiğini görüyoruz. gerekenden daha az. Durumu düzeltmek için 50'ye bir birim eklememiz yeterli, yani. 50 + 1 = 51, şimdi ortaya çıkan sayı, yöntem tarafından döndürülen olası maksimum sayı ile çarpılırsa, 50.9 sayısını alacağız ... - ihtiyacımız olan şey bu, 50.9 + 50 sayılarını ekledikten sonra 100,9 elde ediyoruz. . Bir sayıyı bir tam sayıya yuvarlamak için Math.floor () yöntemini kullanın. Böylece, istenen sayıyı elde etmenin formülü şöyle görünür: Aşağıdaki şekilde: max - min + 1. Yukarıdaki örneği yeniden yazalım:

Var maks = 100, min = 50; document.write (Math.floor (Math.random () * (maks - min + 1) + min));

Bu formül, özellikle hangi aralıkta rastgele bir sayı almak istediğinizi önceden bilmediğiniz durumlarda kullanışlıdır.

Örnek

1 ile 10 arasında bir sözde rastgele sayı.

2 Haziran 2013, 22:56

JavaScript kontrollü rastgele

• JavaScript

Bir dizideki değerleri tekrar etmeden rastgele örneklemek için "Algoritma". Daha spesifik olarak, JS eğitiminin bir parçası olarak, sınıfları ve isimleri tekrar etmeden klasik bir RPG karakter grubu (barbar, sihirbaz, hırsız, şövalye, rahip) oluşturmak için kullandım.

İlke son derece basittir, ancak benim gibi JS'ye yeni başlayanlar için faydalı olabilir. RPG'ye olan bağlantı son derece semboliktir - şimdi aktif olarak profilimi pazarlamadan BT'ye değiştirmeye çalışıyorum (ruhumun yalan söylediğini anladım) ve pratik yapıyorum. oyun formuçok daha ilginç.

1. Bir şablon oluşturun

Bir karakter grubu oluşturmadan önce, onları oluşturmak için bir şablon ayarlamanız gerekir. Aslında burada:

Fonksiyon GamePlayer (n, r, l, p) (this.nick = n; this.role = r; this.level = l; this.portrait = p;)
Aslında, bu fonksiyon çağrılacağı değişkenlerden karakterler yaratacaktır. Örneğin:

Var player1 = new GamePlayer ("Power Ranger", "barbar", "64", "img / barbarian.jpg")
Artık player1 değişkeni, belirli bir portreye sahip 64. seviye bir Power Ranger barbarını saklar; player1.nick, player1.level, vb. kullanarak sayfanın herhangi bir parametresini görüntüleyebiliriz.

GamePlayer'dan gelen değerler (n, r, l, p) fonksiyona veri almaktan ve almaktan sorumludur. Örnekte n ve r değiştirilirse, güçlü korucu Barbarian, göreve tam olarak uymayan oyuncu1'de kalacaktır.

2. Dizileri ayarlama

Karakterleri kendi başımıza değil, neredeyse rastgele oluşturmak için (başlıkta söz verildiği gibi), bu karakterlerin parametrelerini alacağımız dizilere ihtiyacımız var. Yukarıda açıklandığı gibi sadece 4 parametremiz var: karakter adı, sınıf, seviye ve portre.

İsim için dizi:

Var playerNames = ["Rabbit Helpless", "Warm Dreaded Foal", "Desire Kit", "Angel Dusty", "Sweety Frozen", "Silver Heavy Wombat", "Lost Puma", "Vital Panda", "Rolling Sun" , "Çelik Akıntısı", "Genç Tilki", "Gereksiz Acımasız Gönüllü", "Sincap Kültü", "İndigo Köpek Yavrusu"];
Daha ileri gitmek ve 2-3 bileşenden isimler oluşturmak mümkün olurdu, ancak böyle bir iyileştirme için algoritma yeni bir şey içermiyor (aynı rastgele) ve o zaman basitçe karmaşık olurdu. çalışma süreci.

Sınıf için dizi:

Var playerRoles = ["barbar", "büyücü", "haydut", "şövalye", "rahip"];
Her şey aynı derecede açıktır. Daha sonra sayfada görüntülenecek değerleri seçeceğimiz birkaç dize.

Seviye için dizi:

V özel örnek, Tüm grup üyelerinin seviye 60'tan 70'e kadar olmasını istedim. Ancak, koşullar değişebileceğinden, 0'dan 80'e kadar bir dizi oluşturmak gerekiyordu ve bu diziler arasından istenen değerler seçiliyordu. Bir döngüde oluşturuldu:

Var playerLevels =; için (i = 0; ben<= 80;i++) { console.log(i); playerLevels[i] = i; }
Sonuç, her hücresi kendi numarasına sahip bir int içeren bir playerLevels dizisidir.

Portreler için dizi:

Var playerPortraits = ["img / barbar.jpg", "img / mage.jpg", "img / rogue.jpg", img / knight.jpg "," img / rahip.jpg "];
Aynı prensip, ancak metin yerine resimlere bağlantılar kullanıyoruz. Ayrıca, bunları istenen div'in background-image parametresinde (veya herkes için daha uygun olduğu için istenen görüntünün src parametresinde) değiştirebiliriz.

playerPortraits dizisindeki resimlerin sırasının playerRoles dizisindeki sınıfların sırası ile aynı olması önemlidir, o zaman onları oluşturmak için aynı rastgele değişkeni kullanabiliriz (böylece resim sınıfla eşleşir).

3. Karakter oluşturma

Dediğim gibi grupta 5 karakter olmalı. Bu nedenle, bir döngü oluşturuyoruz:

için (i = 0; ben<=4;i++) { }
Döngüden önce, gelecekteki karakterlerimiz için bir dizi bildirmek önemlidir:

Var oyuncular =;

Var namerand = Math.floor (Math.random () * playerNames.length)

• Marh.random () rastgele bir sayı üretmek için kullanılır;
• playerNames.length ile çarpma (playerNames dizisinin uzunluğu) - rasgele sayıyı dizideki ad sayısıyla sınırlamak için;
• Math.floor - elde edilen sayıyı bir tam sayıya dönüştürmek için.

Nüans, Math.floor'un aşağı yuvarlanmasıdır, ancak dizilerdeki numaralandırma 0'dan başladığı için bize uyar.

Sınıf oluşturma

Prensip ve uygulama aynıdır:

Var rolerand = Math.floor (Math.random () * (playerRoles.length));
Tek fark, sınıflar için playerRoles dizisini kullanmamızdır.

Seviye üretimi

Var levelrand = Math.floor (Math.random () * (70 - 60 + 1) + 60);
Belirli bir aralıkta rastgele hesaplama Math.random () * (maks - min) + min formülüne göre gerçekleşir.

Örnekte, 0'dan 10'a kadar rasgeleyi alıyoruz ve sonra buna 60 ekleyerek 60 + 0 ile 60 + 10 arasında bir aralık elde ediyoruz (ihtiyacımız olan şey bu). Math.floor kullanımı nedeniyle bir birim eklemek gereklidir (yukarıyı okuyun).

Karakter oluşturma

Ön son adım. Bir karakter oluşturmak için ilk örnekte olduğu gibi tüm parametrelerini tek bir değişkende birleştirmemiz gerekiyor. Şuna benziyor:

Oyuncular [i] = yeni GamePlayer (playerNames, playerRoles, playerLevels, playerPortraits);
Aslında, her karakter kendi sıra numarasıyla oyuncular dizisinin bir öğesi olur. Parametreleri:

• oyuncuAdları - ad, adlardan rastgele seçim (oyuncuAdlarında adın altındaki hücre ve sayı);
• playerRoles - sınıf, sınıflardan rastgele seçim;
• playerLevels - 60-70 aralığında sınıf, rastgele seviye seçimi;
• playerPortraits - portre, portrelerden rastgele seçim.

Yukarıda belirttiğim gibi, "resmin eşleşmesi" için portre ve sınıf dizileri aynı olmalıdır; bu nedenle her iki durumda da aynı rastgeleyi kullanabiliriz.

Kontrollü rastgele

Son. Olduğu gibi bırakılırsa çalışır. Ancak, aynı isimlere sahip çok farklı sınıflardan (örneğin 3 sihirbaz ve 2 hırsız) bir grup karakter elde edeceğiz. Bunu önlemek için birkaç basit adım yeterlidir:

Oyuncular [i] = yeni GamePlayer (playerNames, playerRoles, playerLevels, playerPortraits); playerNames.splice (isimrand, 1); playerRoles.splice (rolerand, 1); playerPortraits.splice (rolerand, 1);
Karaktere parametreler atadıktan hemen sonra hücrelerini karşılık gelen dizilerden çıkarıyoruz.

Daha spesifik olarak, playerNames.splice (namerand, 1) slot numaralı namerand'ı, splice işlemini kullanarak playerNames dizisinden kaldırır. Ondalık noktadan sonraki birim, belirtilenden başlayarak kaç hücrenin silinmesi gerektiğini gösterir; sadece birini, belirtilen hücrenin kendisini silmemiz gerekiyor.

Ayrıca, döngü tekrar tekrar eder ve dizinin son hücresine rastlarsa tanımsız olarak dönebilir (sonuçta onu 1 azalttık). Ancak Math.random'umuz playerNames.length ve diğerlerini kullandığından, doğrudan dizinin uzunluğuna bağlıdır ve yalnızca yeni, yinelenmeyen değerler üretecektir.

4. Sonuç

Ek olarak, bu betiğin sayfa ile etkileşimini tanımlayabilirsiniz: karakterlerin "kartlarını" görüntülemek, portrelerini yüklemek, vb., ancak bu, ana JS işlevleriyle ilişkili oldukça açık bir işlemdir. Ek olarak, basit el kitabımı zaten biraz sıkılaştırdım. Böylece işlemin görselleştirilmesini örnekte görebilirsiniz.

Teknik olarak, "rastgele sayı üreteci" terimi, sayıların kendileri rastgele olmadığı için saçmadır. Örneğin, 100 rastgele bir sayı mı? ve 25? Bu terimin gerçekten anlamı, rastgele görünen bir sayı dizisi oluşturmasıdır. Bu daha karmaşık bir soruyu akla getiriyor: Rastgele sayı dizisi nedir? Tek doğru cevap: Bir rastgele sayı dizisi, tüm öğelerin ilgisiz olduğu bir dizidir. Bu tanım öyle bir paradoksa yol açar ki, bu dizinin nasıl elde edildiğine bağlı olarak herhangi bir dizi hem rastgele hem de rastgele olmayabilir. Örneğin, aşağıdaki sayı satırı
1 2 3 4 5 6 7 8 9 0
klavyenin üst satırı sırayla yazılarak elde edildi, bu nedenle dizi rastgele oluşturulmuş olarak kabul edilemez. Ama ya numaralandırılmış tenis toplarını fıçıdan çıkararak aynı kıvamı elde ederseniz. Bu durumda, zaten rastgele oluşturulmuş bir dizidir. Bu örnek, bir dizinin rastgeleliğinin kendisine değil, nasıl elde edildiğine bağlı olduğunu göstermektedir.

Bilgisayar tarafından üretilen sayı dizisinin deterministik olduğunu unutmayın: birincisi hariç her sayı kendinden önceki sayılara bağlıdır. Teknik olarak bu, bir bilgisayar tarafından yalnızca yarı rasgele bir sayı dizisinin oluşturulabileceği anlamına gelir; aslında, gerçekten rastgele değiller. Ancak, bu çoğu görev için yeterlidir ve bu tür diziler basitlik için rastgele olarak adlandırılacaktır. John von Neumann tarafından çok ilginç bir yöntem geliştirildi; genellikle kök ortalama kare olarak adlandırılır. Bu yöntemde, bir önceki rastgele sayının karesi alınır ve ardından sonuçtan ortadaki rakamlar çıkarılır. Örneğin, üç basamaklı sayılar oluşturursanız ve önceki sayı 121 ise, kare alma 14641 verir. Ortadaki üç basamağı seçmek sonraki rastgele sayı 464'ü verir. Bu yöntemin dezavantajı, çok kısa bir tekrar süresine sahip olmasıdır. bir döngü... Bu nedenle günümüzde bu yöntem kullanılmamaktadır. Rastgele sayılar üretmenin modern yöntemleri çok daha karmaşıktır.

PHP'de rastgele sayılar

PHP iki grup rasgele sayı işlevine sahiptir. Dışa doğru, gruplardan birinin tüm işlevleri için mt_ öneki ile ayırt edilebilirler.

Kullanımdan kaldırılan işlevler
Rand. Sıfırdan RAND_MAX'a (32767 olan) bir tamsayı döndürür. İki isteğe bağlı tamsayı parametresine sahip olabilir - bunlar belirtilirse, ilk parametreden ikinciye rastgele bir sayı oluşturulur.

Yankı randı (); yankı randı (1,100); // 1'den 100'e kadar rastgele bir sayı ver

Srand. Rand işlevi tarafından üretilen rasgele sayıların sırasını belirtir. Bir tamsayı parametresine sahiptir - bu parametrenin farklı değerleri için rand, farklı sayı dizileri üretecektir. Rand işlevine yapılan tüm çağrılardan önce srand işlevinin yalnızca bir kez çağrılması gerekir. Kullanım örneği:

Srand (1288); // ($ i = 0; $ i) için rasgele sayı üretecini başlat<5;$i++){ echo rand(); echo "
"; }

Dikkat! PHP 4.2.0'dan beri, srand() öğesini çağırmanıza gerek yoktur - PHP bunu otomatik olarak yapar.
Getrandmax() işlevi. Maksimum rastgele sayının (32767) değerini döndürür.

İkinci grubun işlevleri (mt_ öneki ile)
Adları ve eylemleri, ilk grubun işlevlerine benzer - mt_rand, mt_srand ve mt_getrandmax. Temel fark, rastgele sayıların daha geniş bir aralıktan alınmasıdır: 0'dan 21937 - 1'e. Üstelik bu işlevler, 1997'de Japon bilim adamları tarafından geliştirilen Mersenne Twister rasgele sayı üretecini kullandıkları için eski karşılıklarından çok daha hızlı çalışır. Bu nedenle mt_ (Mersenne Twister) öneki.
Kullanım örneği:

// 1000'den 2000'e kadar rastgele bir sayı üretin echo mt_rand (1000, 2000);

JavaScript'te rastgele sayılar

JavaScript'te rastgele sayı Math.random() kullanılarak oluşturulabilir. Ancak, 0 ile 1 arasında bir kesirli sayı olacaktır (0 ve 1 dahil değil). İstenilen aralıkta rastgele bir tamsayı oluşturmak için kendi fonksiyonunuzu yazmanız gerekir.

JavaScript hesaplamaları çoğu zaman tam olarak istediğimiz sonuçları vermez. Elbette sayılarla her şeyi yapabiliriz - yukarı veya aşağı yuvarlama, aralıkları ayarlama, gereksiz sayıları belirli sayıda ondalık basamağa kesme, bunların hepsi gelecekte bu sayı ile ne yapmak istediğinize bağlıdır.

Yuvarlama neden gereklidir?

JavaScript'in merak uyandıran yönlerinden biri, aslında tamsayıları saklamamasıdır, hemen kayan noktalı sayılarla çalışıyoruz. Bu, birçok kesirli değerin sonlu sayıda ondalık basamakta ifade edilememesi gerçeğiyle birleştiğinde, JavaScript'te şöyle sonuçlar elde edebiliriz:

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
Pratik amaçlar için, bu yanlışlık hiç önemli değil, bizim durumumuzda kentilyonluk bir hatadan bahsediyoruz, ancak bu birilerini hayal kırıklığına uğratabilir. Para birimlerinin, yüzdelerin veya dosya boyutlarının değerlerini temsil eden sayılarla çalışırken biraz garip bir sonuç alabiliriz. Bu yanlışlıkları düzeltmek için, ondalık kesinliği ayarlamak yeterliyken, sonuçları yuvarlamamız yeterlidir.

Yuvarlama sayıları pratik bir uygulamaya sahiptir, belirli bir aralıktaki bir sayıyı değiştirebiliriz, örneğin değeri en yakın tam sayıya yuvarlamak istiyoruz ve sadece ondalık kısımla çalışmıyoruz.

Ondalık sayıları yuvarlama

Ondalık bir sayıyı çıkarmak için toFixed veya toPrecision yöntemini kullanın. Her ikisi de, sırasıyla, kaç tane anlamlı basamak (yani, sayıda kullanılan toplam basamak sayısı) veya ondalık basamak (ondalık noktadan sonraki sayı) sonucun içermesi gerektiğini belirleyen tek bir argüman alır:

1. Argüman toFixed () için tanımlanmadıysa, varsayılan olarak sıfır olur, bu da 0 ondalık basamak anlamına gelir, argümanın maksimum değeri 20'dir.
2. toPrecision için herhangi bir argüman verilmezse, numaraya dokunulmaz

randNum = 6.25 olsun; randNum.toSabit (); > "6" Math.PI.toPrecision (1); > "3" randNum = 87.335; randNum.toSabit (2); > "87.33" randNum = 87.337; randNum.toPrecision (3); > "87,3"
Hem toFixed () hem de toPrecision (), bir sayı değil, sonucun bir dize temsilini döndürür. Bu, yuvarlanan değer randNum ile toplandığında, sayıların toplamı değil, dizelerin birleştirileceği anlamına gelir:

randNum = 6.25 olsun; yuvarlatalım = randNum.toFixed(); // "6" console.log (randNum + yuvarlatılmış); > "6.256"
Sonucun sayısal bir veri türüne sahip olmasını istiyorsanız, parseFloat kullanmanız gerekir:

randNum = 6.25 olsun; let yuvarlatılmış = parseFloat (randNum.toFixed (1)); konsol.log (yuvarlak); > 6.3
Nadir durumlar dışında 5 değerin yuvarlandığını unutmayın.

toFixed () ve toPrecision () yöntemleri, yalnızca kesirli kısmı çıkarmakla kalmayıp, aynı zamanda para birimiyle çalışırken uygun olan ondalık basamakları da tamamlayabildikleri için yararlıdır:

BütünNum = 1 olsun dolarCents = bütünNum.toFixed (2); konsol.log (dolar sent); > "1.00"
Tam sayıların sayısı kesinliğin kendisinden büyükse, toPrecision'ın sonucu üstel gösterimde vereceğini lütfen unutmayın:

Sayı = 123.435 num.toPrecision (2) olsun; > "1.2e + 2"

Ondalık sayılarla yuvarlama hatalarından nasıl kaçınılır

Bazı durumlarda, toFixed ve toPrecision 5'i aşağı ve yukarı yuvarlar:

numTest = 1.005 olsun; numTest.toSabit (2); > "1.00"
Yukarıdaki hesaplama sonucu 1 değil 1.01 olmalıydı. Bu hatayı önlemek istiyorsanız, Jack L Moore'un önerdiği, üstel sayıları kullanarak hesaplamak için önerdiği çözümü kullanabiliriz:

Fonksiyon turu (değer, ondalık sayılar) (dönüş Sayısı (Math.round (değer + "e" + ondalık sayılar) + "e -" + ondalık sayılar);)
Şimdi:

Tur (1.005.2); > 1.01
Yukarıda gösterilenden daha sağlam bir çözüm istiyorsanız, MDN'ye gidebilirsiniz.

Makine epsilon yuvarlama

ES6'da ondalık sayıları yuvarlamak için alternatif bir yöntem tanıtıldı. Makine epsilon yuvarlaması, iki kayan noktalı sayıyı karşılaştırırken makul bir hata payı sağlar. Yuvarlama olmadan, karşılaştırmalar aşağıdakine benzer sonuçlar verebilir:

0.1 + 0.2 === 0.3> yanlış
Doğru karşılaştırmayı elde etmek için fonksiyonumuzda Math.EPSILON kullanıyoruz:

epsEqu (x, y) işlevi (Math.abs (x - y) döndürür)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
İşlev iki argüman alır: ilki mevcut hesaplama, ikincisi ise beklenen sonuçtur. İkisinin bir karşılaştırmasını döndürür:

EpsEqu (0,1 + 0,2, 0,3)> doğru
Tüm modern tarayıcılar zaten ES6 matematik işlevlerini destekler, ancak IE 11 gibi tarayıcılarda destek istiyorsanız çoklu dolgu kullanın.

kesirli kırpma

Yukarıda sunulan tüm yöntemler, ondalık sayılara nasıl yuvarlanacağını bilir. Sayıyı iki ondalık basamağa kesmek için önce 100 ile çarpmanız ve ardından sonucu 100'e bölmeniz gerekir:

İşlev kısaltıldı (sayı) (dönüş Math.trunc (sayı * 100) / 100;) kısaltıldı (3.1416)> 3.14
Yöntemi herhangi bir sayıda ondalık basamağa uyarlamak istiyorsanız, çift bit düzeyinde olumsuzlamayı kullanabilirsiniz:

İşlev kesildi (num, decimalPlaces) (let numPowerConverter = Math.pow (10, decimalPlaces); dönüş ~~ (num * numPowerConverter) / numPowerConverter;)
Şimdi:

randInt = 35.874993 olsun; kesilmiş (randInt, 3); > 35.874

En yakın sayıya yuvarlama

Bir ondalık sayıyı yukarı veya aşağı yuvarlamak için, hangisi en yakınsa, Math.round() öğesini kullanın:

Math.round (4.3)> 4 Math.round (4.5)> 5
"Yarı değerin" 0,5'in matematik kurallarına göre yuvarlandığına dikkat edin.

En yakın tam sayıya yuvarlama

Her zaman aşağı yuvarlamak istiyorsanız Math.floor'u kullanın:

Math.floor (42.23); > 42 Math.floor (36.93); > 36
Negatif olanlar da dahil olmak üzere tüm sayılar için aşağı yuvarlamanın işe yaradığını unutmayın. Alt kattakiler de dahil (negatif sayıları temsil eden) sonsuz sayıda katı olan bir gökdelen hayal edin. Asansörün alt katında 2 ile 3 arasında (ki bu -2,5 değeridir) iseniz, Math.floor sizi -3'e indirecektir:

Math.floor (-2.5); > -3
Ancak bu durumdan kaçınmak istiyorsanız, tüm modern tarayıcılarda (IE/Edge hariç) desteklenen Math.trunc'u kullanın:

Math.trunc (-41.43); > -41
MDN'de, tarayıcılarda ve IE / Edge'de Math.trunc için destek sağlayacak bir çoklu dolgu bulacaksınız.

En yakın tam sayıya yuvarlama

Öte yandan, her zaman toplamanız gerekiyorsa Math.ceil kullanın. Yine, sonsuz artışı hatırlayalım: Math.ceil, sayının negatif olup olmadığına bakılmaksızın her zaman yukarı çıkacaktır:

Math.ceil (42.23); > 43 Math.ceil (36.93); > 37 Math.ceil (-36.93); > -36

Gerektiğinde yukarı / aşağı yuvarlama

5'in en yakın katına yuvarlamak istiyorsak, en basit yol bir sayıyı 5'e bölen, yuvarlayan ve sonra aynı miktarla çarpan bir fonksiyon oluşturmaktır:

RoundTo5 (sayı) işlevi (dönüş Math.round (sayı / 5) * 5;)
Şimdi:

RoundTo5 (11); > 10
Değerinizin katlarına yuvarlamak istiyorsanız, daha genel bir işlev kullanırız, bir başlangıç ​​değeri ve bir kat geçirerek:

roundToMultiple (sayı, çoklu) işlevi (Math.round'u (sayı / çoklu) * çoklu döndür;)
Şimdi:

initialNumber = 11 olsun; çoklu = 10 olsun; roundToMultiple (ilkSayı, çoklu); > 10;

Bir aralıktaki bir sayıyı sabitleme

Bir aralıkta x almak istediğimiz birçok durum vardır. Örneğin, 1 ile 100 arasında bir değer isteyebiliriz, ancak 123 değerini aldık. Bunu düzeltmek için min (bir sayı kümesinin en küçüğünü döndürür) ve max (herhangi bir sayı kümesinin en büyüğünü döndürür) kullanabiliriz. ). Örneğimizde, aralık 1 ile 100 arasındadır:

lowBound = 1 olsun; yüksekBound = 100 olsun; numInput = 123 olsun; let kenetlenmiş = Math.max (lowBound, Math.min (numInput, highBound)); konsol.log (kenetlenmiş); > 100;
Yine, işlemi yeniden kullanabilir ve her şeyi bir fonksiyona sarabiliriz, hadi Daniel X tarafından önerilen çözümü kullanalım. Moore:

Number.prototype.clamp = fonksiyon (min, maks) (dönüş Math.min (Math.maks (bu, min), maks););
Şimdi:

NumInput.clamp (düşükBound, yüksekBound); > 100;

Gauss yuvarlaması

Yuva yuvarlama olarak da bilinen Gauss yuvarlaması, yuvarlamanın en yakın çifte gerçekleştiği yerdir. Bu yuvarlama yöntemi istatistiksel hata olmadan çalışır. En iyi çözüm Tim Down tarafından önerildi:

gaussRound (num, decimalPlaces) işlevi (let d = decimalPlaces || 0, m = Math.pow (10, d), n = + (d? Num * m: num) .toSabit (8), i = Math.floor (n), f = n - i, e = 1e-8, r = (f> 0,5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
Şimdi:

GaussRound (2.5)> 2 gaussRound (3.5)> 4 gaussRound (2.57,1)> 2,6
CSS'de ondalık nokta:

JavaScript genellikle HTML öğelerinin konumsal dönüşümlerini oluşturmak için kullanıldığından, öğelerimiz için ondalık değerler oluşturduğumuzda ne olacağını merak edebilirsiniz:

#kutu (genişlik: 63.667731993 piksel;)
İyi haber şu ki, modern tarayıcılar, yüzde veya piksel birimleri dahil olmak üzere kutu modelindeki ondalık değerleri dikkate alacaktır.

sıralama

Çoğu zaman bazı öğeleri sıralamamız gerekir, örneğin, bir dizi oyun kaydımız var ve bunlar oyuncuların sıralamasına göre azalan düzende düzenlenmelidir. Ne yazık ki, standart sıralama () yönteminin bazı şaşırtıcı sınırlamaları vardır: yaygın olarak kullanılan İngilizce sözcüklerle iyi çalışır, ancak sayılar, benzersiz karakterler veya büyük harflerle karşılaşıldığında hemen bozulur.

Alfabetik olarak sırala

Bir diziyi alfabetik olarak sıralamanın en basit görev olması gerektiği anlaşılıyor:

Let meyve = ["balkabağı", "kayısı", "kavun"]; meyve.sort(); > "kayısı", "balkabağı", "kavun"]
Ancak, öğelerden biri büyük harf olduğunda bir sorunla karşılaşıyoruz:

Let meyve = ["butternut squash", "kayısı", "Cantalope"]; meyve.sort(); > "kavun", "kayısı", "balkabağı"]
Bunun nedeni, sıralayıcının varsayılan olarak Unicode'da temsil edilen ilk karakteri karşılaştırmasıdır. Unicode, platformdan bağımsız olarak, programdan bağımsız olarak, dilden bağımsız olarak herhangi bir karakter için benzersiz bir koddur. Örneğin, kod tablosuna bakarsanız, "a" karakteri U + 0061 değerine sahiptir (onaltılık sistemde 0x61), "C" karakteri ise U + 0043 (0x43) koduna sahiptir. "A" karakterinden daha Unicode tablosu.

Karışık ilk harfler içeren bir diziyi sıralamak için, tüm öğeleri geçici olarak küçük harfe dönüştürmemiz veya bazı argümanlarla localeCompare () yöntemini kullanarak kendi sıralama düzenimizi tanımlamamız gerekir. Kural olarak, böyle bir durumda, tekrarlanan kullanım için hemen bir işlev oluşturmak daha iyidir:

işlev alphaSort (dizi) (dizi.sort (a, b) (dönüş a.localeCompare (b, "tr", ("duyarlılık": "temel"));));) let meyve = ["butternut squash "," kayısı "," Kavun "]; alphaSort (meyve)>
Ters alfabetik sıraya göre sıralanmış bir dizi elde etmek istiyorsanız, işlevde a ve b konumlarını değiştirmeniz yeterlidir:

işlev alphaSort (dizi) (dizi.sort (a, b) işlevi (dönüş b.localeCompare (a, "tr", ("duyarlılık": "taban"));) let meyve = ["butternut squash "," kayısı "," Kavun "]; alphaSort (meyve)> ["kavun", "butternut squash", "kayısı"]
Burada localeCompare'in argümanlarla kullanıldığını belirtmekte fayda var, ayrıca IE11 + tarafından desteklendiğini de hatırlamanız gerekir, IE'nin eski sürümleri için argümanlar olmadan ve küçük harflerle kullanabiliriz:

caseSort (arr) (arr.sort (a, b) (return a.toLowerCase (). LocaleCompare (b.toLowerCase ());));) let meyve = ["butternut squash", "kayısı", "Kavun"]; caseSort (meyve)> ["kayısı", "butternut squash", "Cantaloupe"]

sayısal sıralama

Bütün bunlar, oyun kayıtları dizisi hakkında yukarıda bahsettiğimiz örnek için geçerli değildir. Bazı sayısal dizilerde sıralama gayet iyi çalışır, ancak bir noktada sonuç tahmin edilemez olabilir:

Yüksek Skorlar olsun =; yüksekScores.sort(); >
Gerçek şu ki, sort () yöntemi sözlükbilimsel bir karşılaştırma gerçekleştirir: bu, sayıların bir dizeye dönüştürüleceği ve bu dizenin ilk karakterini Unicode tablo karakterlerinin sırasına göre eşleştirerek karşılaştırmaların yeniden gerçekleştirileceği anlamına gelir. Bu nedenle, sıralama düzenimizi tekrar tanımlamamız gerekiyor:

Yüksek Skorlar olsun =; highScores.sort (işlev (a, b) (dönüş a - b;)); >
Yine sayıları ters sırada sıralamak için fonksiyonda a ve b'nin yerlerini değiştirin.

JSON benzeri bir yapıyı sıralama

Son olarak, bir dizi oyun kaydı olarak temsil edilen JSON benzeri bir veri yapımız varsa:

Let puanları = [("isim": "Daniel", "puan": 21768), ("isim": "Michael", "puan": 33579), ("isim": "Alison", "puan": 38395 )];
ES6 +'da ok işlevlerini kullanabilirsiniz:

Skorlar.sort ((a, b) => b.score - a.score));
Bu desteğe sahip olmayan eski tarayıcılar için:

Skorlar.sort (işlev (a, b) (dönüş a.score - b.score));
Gördüğünüz gibi JavaScript'te sıralama yapmak bariz bir şey değil, umarım bu örnekler hayatı bir şekilde kolaylaştırır.

Güç fonksiyonlarıyla çalışma

Üs alma, başlangıçta bir doğal sayının kendisiyle birden çok çarpımının sonucu olarak tanımlanan bir işlemdir, a'nın karekökü, karesi alındığında a veren sayıdır. Alanları, hacimleri hesaplarken ve hatta fiziksel modelleme de dahil olmak üzere matematik derslerinde bu işlevleri günlük hayatta her zaman kullanabiliriz.

JavaScript'te üstel işlev Math.pow () olarak temsil edilir, yeni ES7 standardında yeni bir üstel alma operatörü tanıtıldı - "* *".

üs alma

Bir sayıyı n'inci kuvvete yükseltmek için Math.pow() işlevini kullanın; burada ilk argüman, kuvvete yükseltilecek sayıdır, ikinci argüman üsdür:

Matematik.güç (3,2)> 9
Bu gösterim şekli 3 kare veya 3 × 3 anlamına gelir ve bu da 9 sonucunu verir. Başka bir örnek de verebilirsiniz tabii ki:

Math.pow (5.3); > 125
Yani 5 küp veya 5 × 5 × 5 125'e eşittir.

ECMAScript 7, JavaScript'in sonraki sürümüdür, prensip olarak, önerilen yeni üs alma operatörünü kullanabiliriz - * *, bu gösterim şekli daha açıklayıcı olabilir:

3 ** 2 > 9
Şu anda, bu operatör için destek oldukça sınırlıdır, bu nedenle kullanılması önerilmez.

Bir güç işlevi, çok çeşitli durumlarda kullanışlı olabilir. Basit bir örnek, bir saatteki saniye sayısını hesaplamak: Math.pow (60,2).

Kare ve küp kök

Math.sqrt() ve Math.cbrt(), Math.pow() işlevinin tersidir. A'nın karekökünün, karesi alındığında a'yı veren sayı olduğunu unutmayın.

Matematik.sqrt (9)> 3
Aynı zamanda a sayısının küp kökü, küp haline getirildiğinde a veren sayıdır.

Math.cbrt (125)> 5
Math.cbrt (), JavaScript spesifikasyonuna çok yakın bir zamanda tanıtıldı ve bu nedenle yalnızca modern tarayıcılarda destekleniyor: Chrome 38+, Firefox ve Opera 25+ ve Safari 7.1+. Internet Explorer'ın bu listede olmadığını fark edeceksiniz, ancak MDN'de bir çoklu dolgu bulacaksınız.

Örnekleri

Elbette tamsayı olmayan değerleri de şu fonksiyonlardan birinde kullanabiliriz:

Math.pow (1.25, 2); > 1.5625 Math.cbrt (56.57)> 3.8387991760286138
Bunun, negatif bağımsız değişken değerleri kullanırken de işe yaradığını unutmayın:

Math.pow (-5,2)> 25 Math.pow (10, -2)> 0.01
Ancak, bir karekök için bu işe yaramaz:

Math.sqrt (-9)> NaN
Matematiksel analizden, hayali bir sayının negatif sayıların karekökleri olarak anlaşıldığını biliyoruz. Ve bu bizi karmaşık sayılarla çalışmak için başka bir tekniğe götürebilir, ama bu başka bir hikaye.

Sayıların kare ve küp köklerini bulmak için Math.pow() içindeki kesirli değerleri kullanabilirsiniz. Karekök, 0,5'lik bir üs kullanır:

Math.pow (5, 0,5); // = Math.sqrt (5) = 5 ** (1/2)> 2.23606797749979
Ancak, kayan nokta değişkenleri nedeniyle, doğru sonucu doğru bir şekilde tahmin edemezsiniz:

Math.pow (2.23606797749979.2)> 5.00000000000001
Bu gibi durumlarda, sayıdan veya bir değere yuvarlamadan işaretleri kısaltmaya başvurmanız gerekecektir.

Bazıları, JavaScript'te bilinmeyen bir nedenle Math.pow() işlevini, genel olarak sayılar için üstel bir işlev olan Math.exp() ile karıştırır. Not: İngilizce'de "üs", "üs" olarak çevrilir, bu nedenle üs için indeks, güç gibi alternatif isimler olmasına rağmen, bunun İngilizce konuşanlara atıfta bulunması daha olasıdır.

matematiksel sabitler

JavaScript'te matematikle çalışmak, bir dizi yerleşik sabit tarafından kolaylaştırılmıştır. Bu sabitler Math nesnesinin özellikleridir. Sabitlerin CamelCase notasyonu değil büyük harfle yazıldığını belirtmekte fayda var.

Ankete sadece kayıtlı kullanıcılar katılabilir. Gelin lütfen.

Etiketler:

• javascript
• Matematik

Etiket ekle