Javascript làm tròn đến 25 gần nhất

Analysis Toolpak đi kèm với Excel - nó là một phần của Excel tiêu chuẩn, nhưng bạn phải kích hoạt addin

xem tại đây để được hướng dẫn

http. //văn phòng. Microsoft. com/en…tance/HP011277241033. aspx

Sau đó, bạn có thể sử dụng công thức

=MROUND(A1,0. 25)

Giả sử A1 chứa 4. 78, đáp án sẽ là 4. 75

Trân trọng, Will Riley

LinkedIn. Will Riley

Will Riley

hiệp sĩ

44,925Bài viết8,649

Lại. Làm tròn đến gần nhất. 25

Bạn có thể đính kèm một ví dụ nhỏ về những gì bạn đang cố gắng làm không

Trích dẫn

Tôi đang học chương trình và tôi tóc vàng

[Hình ảnh bị chặn. http. //www. thecodenet. com/forum/smilies/rofl. gif]
[Hình ảnh bị chặn. http. //www. thecodenet. com/forum/smilies/pound. gif]

Chỉ có những câu trả lời ngu ngốc ở đây. Chưa có câu hỏi ngu ngốc

Trân trọng, Will Riley

LinkedIn. Will Riley

Will Riley

hiệp sĩ

44,925Bài viết8,649

Lại. Làm tròn đến gần nhất. 25

OK, tôi có thể hiểu những gì anh ấy đang làm, nhưng anh ấy hơi mơ hồ nếu anh ấy được cho là đang dạy bạn. Ý tôi là, bạn không biết Excel phải không?

OK, trừ khi bạn biết Excel, bạn sẽ không biết cách lưu trữ ngày và giờ đặc biệt của nó

Ngày được lưu trữ bằng số, bắt đầu bằng số 1 (là ngày 1/1/1900) - trên cơ sở đó, Excl nhận ra hôm nay là 38.384 - đây là lý do tại sao chúng ta có thể trừ 1 ngày từ ngày khác và tính số ngày đã trôi qua

Giá trị thời gian là tương tự. Giả sử rằng 24 giờ có giá trị là 1 (tính theo ngày), logic sau đây sẽ có ý nghĩa

24 giờ có thể được đo bằng 1/24

i. e. nếu một ngày (theo thuật ngữ excel) là 1 - thì theo đó excel coi một giờ là 1/24

VÂNG. hy vọng bạn vẫn còn với tôi.

Vậy một phần tư giờ là 1/24/4 Đó là 1 chia cho 24 chia cho 4 - giá trị này cũng có thể được biểu thị bằng 1/(24*4)

Vì vậy, hãy quay trở lại vấn đề của chúng ta

Giả sử A1 có thời gian 12. 26

Loại A2

=MROUND(A1,1/(24*4))

Chào. câu trả lời là 12. 30

Đó là những gì bạn muốn

Nếu bạn cần thay đổi nó để làm tròn đến vị trí 10 phút gần nhất. tốt, có 4 * 15 phút trong 1 giờ và 6 * 10 phút

Sử dụng máy tính làm tròn này để làm tròn một số đến bội số gần nhất. Bạn có thể làm tròn một số lên hoặc xuống đến 2, 4, 5, 10, 50, v.v. Bạn cũng có thể làm tròn đến phần mười, phần trăm, phần nghìn, v.v. bội số ở vị trí thập phân

Máy tính này làm tròn lên hoặc xuống bội số gần nhất tương tự như hàm MROUND() trong Excel. Nhập hai số dương hoặc hai số âm

Làm tròn đến bội số gần nhất

Giả sử bạn muốn làm tròn giá trị tiền tệ là $76. 225. Kết quả cuối cùng phụ thuộc vào bội số mà bạn đang làm tròn. Làm tròn 76. 225

• Làm tròn đến mười đô la gần nhất hoặc bội số của 10
  làm tròn đến 80. 00
• Làm tròn đến năm đô la gần nhất hoặc bội số của 5
  làm tròn xuống 75. 00
• Làm tròn đến đô la gần nhất hoặc bội số của 1
  làm tròn xuống 76. 00
• Làm tròn đến 25 xu gần nhất hoặc bội số của 0. 25
  làm tròn lên 76. 25
• Làm tròn đến 10 xu gần nhất hoặc bội số của 0. 10
  làm tròn xuống 76. 20
• Làm tròn đến 5 xu gần nhất hoặc bội số của 0. 05
  làm tròn lên 76. 25
• Làm tròn đến phần trăm hoặc bội số gần nhất của 0. 01
  làm tròn lên 76. 23

Máy tính liên quan

Để tìm hiểu về các quy tắc làm tròn cơ bản, hãy xem Công cụ tính số làm tròn của chúng tôi. Làm tròn thành số nguyên hoặc số thập phân như phần mười, phần trăm, phần nghìn, v.v.

Làm tròn với Excel MROUND()

Hàm Excel MROUND() làm tròn đến bội số gần nhất, nhưng trong một số trường hợp, kết quả có thể khác với mong đợi của bạn. Ví dụ, xem "Tính toán sai với hàm MROUND" tại www. văn phòng lưu trữ. com

Kết quả làm tròn Excel không nhất quán khi áp dụng MROUND(). Bạn có thể khắc phục sự cố này bằng cách áp dụng ROUND() đầu tiên như trong bảng bên dưới

Môi trường từ vựng là một phần của mọi ngữ cảnh thực thi (khung ngăn xếp) và là bản đồ giữa các mã định danh (nghĩa là. tên biến cục bộ) và giá trị

Mỗi chức năng trong JavaScript duy trì một tham chiếu đến môi trường từ vựng bên ngoài của nó. Tham chiếu này được sử dụng để định cấu hình ngữ cảnh thực thi được tạo khi một hàm được gọi. Tham chiếu này cho phép mã bên trong hàm "nhìn thấy" các biến được khai báo bên ngoài hàm, bất kể khi nào và ở đâu hàm được gọi

Nếu một chức năng được gọi bởi một chức năng, đến lượt nó được gọi bởi một chức năng khác, thì một chuỗi tham chiếu đến môi trường từ vựng bên ngoài được tạo. Chuỗi này được gọi là chuỗi phạm vi

Trong đoạn mã sau,

var number = 5.12345;
number = (Math.round(number * 4) / 4).toFixed(2);

4 tạo thành một bao đóng với môi trường từ vựng của bối cảnh thực thi được tạo khi ___________5 được gọi, đóng trên biến ________6

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`

Nói cách khác. trong JavaScript, các hàm mang tham chiếu đến một "hộp trạng thái" riêng tư mà chỉ chúng (và bất kỳ hàm nào khác được khai báo trong cùng một môi trường từ vựng) mới có quyền truy cập. Hộp trạng thái này là vô hình đối với người gọi hàm, cung cấp một cơ chế tuyệt vời để ẩn và đóng gói dữ liệu

Và hãy nhớ. các hàm trong JavaScript có thể được truyền xung quanh giống như các biến (hàm hạng nhất), nghĩa là các cặp chức năng và trạng thái này có thể được truyền xung quanh chương trình của bạn. tương tự như cách bạn có thể truyền một thể hiện của một lớp xung quanh trong C++

Nếu JavaScript không có bao đóng, thì sẽ phải chuyển nhiều trạng thái hơn giữa các hàm một cách rõ ràng, làm cho danh sách tham số dài hơn và mã ồn hơn

Vì vậy, nếu bạn muốn một chức năng luôn có quyền truy cập vào một phần trạng thái riêng tư, bạn có thể sử dụng bao đóng

và chúng ta thường muốn liên kết trạng thái với một chức năng. Ví dụ, trong Java hoặc C++, khi bạn thêm một biến thể hiện riêng và một phương thức vào một lớp, bạn đang liên kết trạng thái với chức năng

Trong C và hầu hết các ngôn ngữ phổ biến khác, sau khi một hàm trả về, tất cả các biến cục bộ không còn truy cập được nữa do khung ngăn xếp bị hủy. Trong JavaScript, nếu bạn khai báo một hàm bên trong một hàm khác, thì các biến cục bộ của hàm bên ngoài vẫn có thể truy cập được sau khi trở về từ hàm đó. Theo cách này, trong đoạn mã trên,

var number = 5.12345;
number = (Math.round(number * 4) / 4).toFixed(2);

6 vẫn có sẵn cho đối tượng hàm

var number = 5.12345;
number = (Math.round(number * 4) / 4).toFixed(2);

4, sau khi nó được trả về từ

var number = 5.12345;
number = (Math.round(number * 4) / 4).toFixed(2);

5

Công dụng của Đóng cửa

Các bao đóng hữu ích bất cứ khi nào bạn cần một trạng thái riêng tư được liên kết với một chức năng. Đây là một kịch bản rất phổ biến - và hãy nhớ. JavaScript không có cú pháp lớp cho đến năm 2015 và nó vẫn không có cú pháp trường riêng. Đóng cửa đáp ứng nhu cầu này

Biến thể hiện cá nhân

Trong đoạn mã sau, hàm

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`

0 đóng trên các chi tiết của ô tô

________số 8_______

Lập trình chức năng

Trong đoạn mã sau, hàm

var number = 5.12345;
number = (Math.round(number * 4) / 4).toFixed(2);

4 đóng trên cả

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`

2 và

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`

3

function curry(fn) {
  const args = []
  return function inner(arg) {
    if(args.length === fn.length) return fn(...args)
    args.push(arg)
    return inner
  }
}

function add(a, b) {
  return a + b
}

const curriedAdd = curry(add)
console.log(curriedAdd(2)(3)()) // 5

Lập trình hướng sự kiện

Trong đoạn mã sau, hàm

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`

4 đóng trên biến

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`

5

const $ = document.querySelector.bind(document)
const BACKGROUND_COLOR = 'rgba(200,200,242,1)'

function onClick() {
  $('body').style.background = BACKGROUND_COLOR
}

$('button').addEventListener('click', onClick)

Set background color

mô đun hóa

Trong ví dụ sau, tất cả các chi tiết triển khai được ẩn bên trong một biểu thức hàm được thực thi ngay lập tức. Các chức năng

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`

6 và

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`

0 đóng trên trạng thái tư nhân và các chức năng họ cần để hoàn thành công việc của mình. Việc đóng cửa đã cho phép chúng tôi mô đun hóa và đóng gói mã của chúng tôi

let namespace = {};

(function foo(n) {
  let numbers = []
  function format(n) {
    return Math.trunc(n)
  }
  function tick() {
    numbers.push(Math.random() * 100)
  }
  function toString() {
    return numbers.map(format)
  }
  n.counter = {
    tick,
    toString
  }
}(namespace))

const counter = namespace.counter
counter.tick()
counter.tick()
console.log(counter.toString())

ví dụ

ví dụ 1

Ví dụ này cho thấy các biến cục bộ không được sao chép trong bao đóng. việc đóng cửa duy trì một tham chiếu đến chính các biến ban đầu. Như thể khung ngăn xếp vẫn tồn tại trong bộ nhớ ngay cả sau khi chức năng bên ngoài thoát

function foo() {
  let x = 42
  let inner  = function() { console.log(x) }
  x = x+1
  return inner
}
var f = foo()
f() // logs 43

ví dụ 2

Trong đoạn mã sau, ba phương thức

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`

8,

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`

9 và

function Car(manufacturer, model, year, color) {
  return {
    toString() {
      return `${manufacturer} ${model} (${year}, ${color})`
    }
  }
}
const car = new Car('Aston Martin','V8 Vantage','2012','Quantum Silver')
console.log(car.toString())

0 đều đóng trên cùng một môi trường từ vựng

Và mỗi khi

function Car(manufacturer, model, year, color) {
  return {
    toString() {
      return `${manufacturer} ${model} (${year}, ${color})`
    }
  }
}
const car = new Car('Aston Martin','V8 Vantage','2012','Quantum Silver')
console.log(car.toString())

1 được gọi, một bối cảnh thực thi mới (khung ngăn xếp) được tạo và một biến hoàn toàn mới

function Car(manufacturer, model, year, color) {
  return {
    toString() {
      return `${manufacturer} ${model} (${year}, ${color})`
    }
  }
}
const car = new Car('Aston Martin','V8 Vantage','2012','Quantum Silver')
console.log(car.toString())

2 và một bộ hàm mới (

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // `secret` is not directly accessible from outside `foo`
f() // The only way to retrieve `secret`, is to invoke `f`

8, v.v. ) được tạo, đóng trên biến mới này

function createObject() {
  let x = 42;
  return {
    log() { console.log(x) },
    increment() { x++ },
    update(value) { x = value }
  }
}

const o = createObject()
o.increment()
o.log() // 43
o.update(5)
o.log() // 5
const p = createObject()
p.log() // 42

ví dụ 3

Nếu bạn đang sử dụng các biến được khai báo bằng cách sử dụng

function Car(manufacturer, model, year, color) {
  return {
    toString() {
      return `${manufacturer} ${model} (${year}, ${color})`
    }
  }
}
const car = new Car('Aston Martin','V8 Vantage','2012','Quantum Silver')
console.log(car.toString())

4, hãy cẩn thận để biết bạn đang đóng biến nào. Các biến được khai báo bằng cách sử dụng

function Car(manufacturer, model, year, color) {
  return {
    toString() {
      return `${manufacturer} ${model} (${year}, ${color})`
    }
  }
}
const car = new Car('Aston Martin','V8 Vantage','2012','Quantum Silver')
console.log(car.toString())

4 được nâng lên. Đây là một vấn đề ít hơn nhiều trong JavaScript hiện đại do sự ra đời của

function Car(manufacturer, model, year, color) {
  return {
    toString() {
      return `${manufacturer} ${model} (${year}, ${color})`
    }
  }
}
const car = new Car('Aston Martin','V8 Vantage','2012','Quantum Silver')
console.log(car.toString())

6 và

function Car(manufacturer, model, year, color) {
  return {
    toString() {
      return `${manufacturer} ${model} (${year}, ${color})`
    }
  }
}
const car = new Car('Aston Martin','V8 Vantage','2012','Quantum Silver')
console.log(car.toString())

7

Trong đoạn mã sau, mỗi lần lặp lại, một hàm mới

var number = 5.12345;
number = (Math.round(number * 4) / 4).toFixed(2);

4 được tạo, hàm này sẽ đóng trên

function Car(manufacturer, model, year, color) {
  return {
    toString() {
      return `${manufacturer} ${model} (${year}, ${color})`
    }
  }
}
const car = new Car('Aston Martin','V8 Vantage','2012','Quantum Silver')
console.log(car.toString())

9. Nhưng vì

function curry(fn) {
  const args = []
  return function inner(arg) {
    if(args.length === fn.length) return fn(...args)
    args.push(arg)
    return inner
  }
}

function add(a, b) {
  return a + b
}

const curriedAdd = curry(add)
console.log(curriedAdd(2)(3)()) // 5

0 được nâng lên bên ngoài vòng lặp, tất cả các hàm bên trong này đóng trên cùng một biến, nghĩa là giá trị cuối cùng của ______8_______9 (3) được in ba lần

var number = 5.12345;
number = (Math.round(number * 4) / 4).toFixed(2);

0

điểm cuối cùng

• Bất cứ khi nào một hàm được khai báo trong JavaScript, bao đóng được tạo
• Trả về một

  function curry(fn) {
    const args = []
    return function inner(arg) {
      if(args.length === fn.length) return fn(...args)
      args.push(arg)
      return inner
    }
  }
  
  function add(a, b) {
    return a + b
  }
  
  const curriedAdd = curry(add)
  console.log(curriedAdd(2)(3)()) // 5

  2 từ bên trong một hàm khác là một ví dụ cổ điển về bao đóng, bởi vì trạng thái bên trong hàm bên ngoài hoàn toàn khả dụng đối với hàm bên trong được trả về, ngay cả sau khi hàm bên ngoài đã hoàn tất thực thi
• Bất cứ khi nào bạn sử dụng

  function curry(fn) {
    const args = []
    return function inner(arg) {
      if(args.length === fn.length) return fn(...args)
      args.push(arg)
      return inner
    }
  }
  
  function add(a, b) {
    return a + b
  }
  
  const curriedAdd = curry(add)
  console.log(curriedAdd(2)(3)()) // 5

  3 bên trong một chức năng, thì bao đóng được sử dụng. Văn bản bạn

  function curry(fn) {
    const args = []
    return function inner(arg) {
      if(args.length === fn.length) return fn(...args)
      args.push(arg)
      return inner
    }
  }
  
  function add(a, b) {
    return a + b
  }
  
  const curriedAdd = curry(add)
  console.log(curriedAdd(2)(3)()) // 5

  4 có thể tham chiếu các biến cục bộ của hàm và ở chế độ không nghiêm ngặt, bạn thậm chí có thể tạo các biến cục bộ mới bằng cách sử dụng

  function curry(fn) {
    const args = []
    return function inner(arg) {
      if(args.length === fn.length) return fn(...args)
      args.push(arg)
      return inner
    }
  }
  
  function add(a, b) {
    return a + b
  }
  
  const curriedAdd = curry(add)
  console.log(curriedAdd(2)(3)()) // 5

  5
• Khi bạn sử dụng

  function curry(fn) {
    const args = []
    return function inner(arg) {
      if(args.length === fn.length) return fn(...args)
      args.push(arg)
      return inner
    }
  }
  
  function add(a, b) {
    return a + b
  }
  
  const curriedAdd = curry(add)
  console.log(curriedAdd(2)(3)()) // 5

  6 (Hàm tạo hàm) bên trong một hàm, nó sẽ không đóng trên môi trường từ vựng của nó. thay vào đó, nó đóng trên bối cảnh toàn cầu. Hàm mới không thể tham chiếu các biến cục bộ của hàm bên ngoài
• Một bao đóng trong JavaScript giống như giữ một tham chiếu (KHÔNG phải là một bản sao) đến phạm vi tại điểm khai báo hàm, từ đó giữ một tham chiếu đến phạm vi bên ngoài của nó, v.v., đến tận đối tượng chung ở đầu
• Một bao đóng được tạo khi một hàm được khai báo;
• Một tập hợp các biến cục bộ mới được tạo mỗi khi một hàm được gọi

liên kết

• Các thuộc tính riêng tư mô phỏng của Douglas Crockford và các phương thức riêng tư cho một đối tượng, sử dụng các bao đóng
• Một lời giải thích tuyệt vời về cách đóng cửa có thể gây rò rỉ bộ nhớ trong IE nếu bạn không cẩn thận
• Tài liệu MDN về Đóng JavaScript

Javascript – Xóa thuộc tính khỏi đối tượng (JavaScript)

Để xóa một thuộc tính khỏi một đối tượng (biến đổi đối tượng), bạn có thể làm như thế này

var number = 5.12345;
number = (Math.round(number * 4) / 4).toFixed(2);

1

Thử nghiệm

var number = 5.12345;
number = (Math.round(number * 4) / 4).toFixed(2);

2

Đối với bất kỳ ai quan tâm đến việc đọc thêm về nó, kangax, người dùng Stack Overflow đã viết một bài đăng blog cực kỳ chuyên sâu về câu lệnh

function curry(fn) {
  const args = []
  return function inner(arg) {
    if(args.length === fn.length) return fn(...args)
    args.push(arg)
    return inner
  }
}

function add(a, b) {
  return a + b
}

const curriedAdd = curry(add)
console.log(curriedAdd(2)(3)()) // 5

7 trên blog của họ, Hiểu về xóa. Nó rất được khuyến khích

Làm cách nào để làm tròn đến 50 trong JavaScript?

Làm cách nào để làm tròn đến 10 điểm thấp nhất trong JavaScript?

Làm cách nào để làm tròn đến số gần nhất trong JavaScript?

Làm cách nào để làm tròn đến 10 gần nhất trong JavaScript?