Software zum Installieren eines Smart-Mirror Frameworks , zum Nutzen von hochschulrelevanten Informationen, auf einem Raspberry-Pi.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

README.md 4.7KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788
  1. # sprintf.js
  2. **sprintf.js** is a complete open source JavaScript sprintf implementation for the *browser* and *node.js*.
  3. Its prototype is simple:
  4. string sprintf(string format , [mixed arg1 [, mixed arg2 [ ,...]]])
  5. The placeholders in the format string are marked by `%` and are followed by one or more of these elements, in this order:
  6. * An optional number followed by a `$` sign that selects which argument index to use for the value. If not specified, arguments will be placed in the same order as the placeholders in the input string.
  7. * An optional `+` sign that forces to preceed the result with a plus or minus sign on numeric values. By default, only the `-` sign is used on negative numbers.
  8. * An optional padding specifier that says what character to use for padding (if specified). Possible values are `0` or any other character precedeed by a `'` (single quote). The default is to pad with *spaces*.
  9. * An optional `-` sign, that causes sprintf to left-align the result of this placeholder. The default is to right-align the result.
  10. * An optional number, that says how many characters the result should have. If the value to be returned is shorter than this number, the result will be padded. When used with the `j` (JSON) type specifier, the padding length specifies the tab size used for indentation.
  11. * An optional precision modifier, consisting of a `.` (dot) followed by a number, that says how many digits should be displayed for floating point numbers. When used with the `g` type specifier, it specifies the number of significant digits. When used on a string, it causes the result to be truncated.
  12. * A type specifier that can be any of:
  13. * `%` — yields a literal `%` character
  14. * `b` — yields an integer as a binary number
  15. * `c` — yields an integer as the character with that ASCII value
  16. * `d` or `i` — yields an integer as a signed decimal number
  17. * `e` — yields a float using scientific notation
  18. * `u` — yields an integer as an unsigned decimal number
  19. * `f` — yields a float as is; see notes on precision above
  20. * `g` — yields a float as is; see notes on precision above
  21. * `o` — yields an integer as an octal number
  22. * `s` — yields a string as is
  23. * `x` — yields an integer as a hexadecimal number (lower-case)
  24. * `X` — yields an integer as a hexadecimal number (upper-case)
  25. * `j` — yields a JavaScript object or array as a JSON encoded string
  26. ## JavaScript `vsprintf`
  27. `vsprintf` is the same as `sprintf` except that it accepts an array of arguments, rather than a variable number of arguments:
  28. vsprintf("The first 4 letters of the english alphabet are: %s, %s, %s and %s", ["a", "b", "c", "d"])
  29. ## Argument swapping
  30. You can also swap the arguments. That is, the order of the placeholders doesn't have to match the order of the arguments. You can do that by simply indicating in the format string which arguments the placeholders refer to:
  31. sprintf("%2$s %3$s a %1$s", "cracker", "Polly", "wants")
  32. And, of course, you can repeat the placeholders without having to increase the number of arguments.
  33. ## Named arguments
  34. Format strings may contain replacement fields rather than positional placeholders. Instead of referring to a certain argument, you can now refer to a certain key within an object. Replacement fields are surrounded by rounded parentheses - `(` and `)` - and begin with a keyword that refers to a key:
  35. var user = {
  36. name: "Dolly"
  37. }
  38. sprintf("Hello %(name)s", user) // Hello Dolly
  39. Keywords in replacement fields can be optionally followed by any number of keywords or indexes:
  40. var users = [
  41. {name: "Dolly"},
  42. {name: "Molly"},
  43. {name: "Polly"}
  44. ]
  45. sprintf("Hello %(users[0].name)s, %(users[1].name)s and %(users[2].name)s", {users: users}) // Hello Dolly, Molly and Polly
  46. Note: mixing positional and named placeholders is not (yet) supported
  47. ## Computed values
  48. You can pass in a function as a dynamic value and it will be invoked (with no arguments) in order to compute the value on-the-fly.
  49. sprintf("Current timestamp: %d", Date.now) // Current timestamp: 1398005382890
  50. sprintf("Current date and time: %s", function() { return new Date().toString() })
  51. # AngularJS
  52. You can now use `sprintf` and `vsprintf` (also aliased as `fmt` and `vfmt` respectively) in your AngularJS projects. See `demo/`.
  53. # Installation
  54. ## Via Bower
  55. bower install sprintf
  56. ## Or as a node.js module
  57. npm install sprintf-js
  58. ### Usage
  59. var sprintf = require("sprintf-js").sprintf,
  60. vsprintf = require("sprintf-js").vsprintf
  61. sprintf("%2$s %3$s a %1$s", "cracker", "Polly", "wants")
  62. vsprintf("The first 4 letters of the english alphabet are: %s, %s, %s and %s", ["a", "b", "c", "d"])
  63. # License
  64. **sprintf.js** is licensed under the terms of the 3-clause BSD license.