AlphaMoatによると、2026-10時点でJavaScriptのダウンロード数は9,327、スター数は14で、累計ダウンロード数で今回のランキング対象AIスキル10,914件中2,953位、開発では1,069件中230位です。
一覧の初期表示は累計ダウンロード数順で、スター数順にも並べ替えできます。詳細ページの順位は累計ダウンロード数で計算しています。
| プラットフォーム | ダウンロード数 | スター数 | コメント |
|---|---|---|---|
| ClawHub ↗ | 7777 | 11 | - |
| SkillHub ↗ | 9327 | 14 | — |
プラットフォームごとに集計方法と集計時点が異なります。
JavaScript が明示または暗示されたときに有効になります。参照、オブジェクト/配列、分割代入、文字列、関数、アロー関数、クラス、ES modules、反復、プロパティアクセス、エラー処理、命名を扱います。const を優先し、再代入が必要な場合は let を使い、var は避けます。厳密等価 ===/!== を優先し、parseInt には必ず radix を指定します。インデント、末尾カンマ、セミコロンも統一します。
資料公開日 2026-10-27
スキルのドキュメントをもとに生成した例であり、実際の実行結果ではありません。
2026-09 から集計方法を変更し、同名スキルを作者ごとに分けて集計し、全スキルを対象にしました。破線は変更前の月で、変更後のデータとは直接比較せず、変更をまたぐ増減も計算していません。 同名の別スキルがあるため、変更前のデータは現在ダウンロード数が最も多いこのスキルに帰属させています。
| 月 | ダウンロード数 | 前月比 | スター数 |
|---|---|---|---|
| 2026-10 | 9327 | — | 14 |
| 2026-09 | 7980 | — | 14 |
| 2026-08 | 7390 | +3.6% | 14 |
| 2026-07 | 7131 | +4.0% | 13 |
| 2026-06 | 6860 | +2.8% | 11 |
| 2026-05 | 6670 | — | 11 |
| 2026-03 | 5375 | — | 5 |
作者が公開した元のファイルをテキストのまま表示しています。AlphaMoat による編集や審査はしていません。リンクはクリックできません。コマンドは内容を確認してから実行してください。取得日 2026-10-23。
--- name: JavaScript license: MIT description: > A comprehensive JavaScript style guide skill. When activated, it provides best-practice JavaScript coding conventions and generates code that strictly follows the style guide, covering variables, functions, objects, arrays, classes, modules, async patterns, error handling, naming conventions, and more. ---
# JavaScript Style Guide Skill
## Activation
This skill activates when the user mentions or implies **JavaScript** in their request. Once activated, it:
- Responds with best-practice guidance
- Generates JavaScript code that strictly conforms to the style guide
- Provides explanations for why each convention is recommended
---
## Complete Style Rules
### 1. References
- Use `const` for all references; avoid `var`.
- If you must reassign references, use `let` instead of `var`.
- Both `const` and `let` are block-scoped, whereas `var` is function-scoped.
```javascript
// bad
var count = 1;
// good
const count = 1;
let mutableValue = 1;
mutableValue += 1;
```
### 2. Objects
- Use literal syntax for object creation.
- Use computed property names when creating objects with dynamic property names.
- Use object method shorthand and property value shorthand.
- Group shorthand properties at the beginning of the object declaration.
- Only quote properties that are invalid identifiers.
- Prefer the object spread syntax (`...`) over `Object.assign` to shallow-copy objects.
```javascript
// bad
const item = new Object();
// good
const item = {};
// computed property names
const key = 'name';
const obj = { [key]: 'value' };
// method & property shorthand
const name = 'Alice';
const atom = {
name,
value: 1,
addValue(val) {
return atom.value + val;
},
};
// shallow copy
const original = { a: 1, b: 2 };
const copy = { ...original, c: 3 };
```
### 3. Arrays
- Use literal syntax for array creation.
- Use `Array.from` or the spread operator to convert array-like objects.
- Use `return` statements in array method callbacks.
- Use line breaks after the opening bracket and before the closing bracket if the array has multiple lines.
```javascript
// bad
const items = new Array();
// good
const items = [];
// convert iterable
const nodes = Array.from(document.querySelectorAll('.item'));
const uniqueValues = [...new Set(arr)];
// array methods
[1, 2, 3].map((x) => x + 1);
[1, 2, 3].map((x) => {
const y = x + 1;
return x * y;
});
```
### 4. Destructuring
- Use object destructuring when accessing multiple properties of an object.
- Use array destructuring.
- Use object destructuring for multiple return values, not array destructuring.
```javascript
// bad
function getFullName(user) {
const firstName = user.firstName;
const lastName = user.lastName;
return `${firstName} ${lastName}`;
}
// good
function getFullName({ firstName, lastName }) {
return `${firstName} ${lastName}`;
}
// array destructuring
const [first, , third] = [1, 2, 3];
// multiple return values — use object destructuring
function processInput(input) {
return { left, right, top, bottom };
}
const { left, top } = processInput(input);
```
### 5. Strings
- Use single quotes `''` for strings.
- Use template literals for string interpolation and multi-line strings.
- Never use `eval()` on a string.
- Do not unnecessarily escape characters in strings.
```javascript
// bad
const name = "Alice";
const greeting = 'Hello, ' + name + '!';
// good
const name = 'Alice';
const greeting = `Hello, ${name}!`;
```
### 6. Functions
- Use named function expressions instead of function declarations.
- Wrap immediately invoked function expressions (IIFE) in parentheses.
- Never declare a function in a non-function block (`if`, `while`, etc.).
- Never name a parameter `arguments`.
- Use default parameter syntax rather than mutating function arguments.
- Always put default parameters last.
- Never use the `Function` constructor to create a new function.
- Use the spread operator `...` to call variadic functions.
- Use rest parameters (`...args`) instead of `arguments`.
```javascript
// named function expression
const short = function longUniqueMoreDescriptiveLexicalFoo() {
// ...
};
// default parameters last
function handleThings(name, opts = {}) {
// ...
}
// rest parameters
function concatenateAll(...args) {
return args.join('');
}
// spread to call
const values = [1, 2, 3];
console.log(Math.max(...values));
```
### 7. Arrow Functions
- Use arrow function notation for anonymous functions (callbacks).
- If the function body consists of a single expression, omit the braces and use the implicit return.
- If the expression spans multiple lines, wrap it in parentheses for readability.
- Always include parentheses around arguments for clarity and consistency.
```javascript
// bad
[1, 2, 3].map(function (x) {
const y = x + 1;
return x * y;
});
// good
[1, 2, 3].map((x) => {
const y = x + 1;
return x * y;
});
// implicit return
[1, 2, 3].map((x) => x * 2);
// multiline implicit return
[1, 2, 3].map((number) => (
`A long string with the ${number}. It's so long that we don't want it to take up space on the .map line!`
));
```
### 8. Classes & Constructors
- Always use `class`; avoid manipulating `prototype` directly.
- Use `extends` for inheritance.
- Methods can return `this` to enable method chaining.
- Classes have a default constructor if no constructor is specified; an empty constructor or one that just delegates to a parent is unnecessary.
- Avoid duplicate class members.
```javascript
// bad
function Queue(contents = []) {
this.queue = [...contents];
}
Queue.prototype.pop = function () {
return this.queue.pop();
};
// good
class Queue {
constructor(contents = []) {
this.queue = [...contents];
}
pop() {
return this.queue.pop();
}
}
// inheritance
class PeekableQueue extends Queue {
peek() {
return this.queue[0];
}
}
```
### 9. Modules
- Always use ES modules (`import`/`export`) over a non-standard module system.
- Do not use wildcard imports.
- Do not export directly from an import.
- Only import from a path in one place.
- Do not export mutable bindings.
- Prefer default export for modules that only export a single thing.
- Put all `import`s above non-import statements.
- Multi-line imports should be indented like multi-line array and object literals.
```javascript
// bad
const utils = require('./utils');
module.exports = utils.fetchData;
// good
import { fetchData } from './utils';
export default fetchData;
// single place import
import { named1, named2 } from 'module';
// multiline
import {
longNameA,
longNameB,
longNameC,
} from 'path/to/module';
```
### 10. Iterators and Generators
- Prefer JavaScript's higher-order functions over `for-in` or `for-of` loops.
- Use `map`, `filter`, `reduce`, `find`, `findIndex`, `every`, `some`, etc.
- Don't use generators for now (if targeting ES5 environments).
```javascript
const numbers = [1, 2, 3, 4, 5];
// bad
let sum = 0;
for (const num of numbers) {
sum += num;
}
// good
const sum = numbers.reduce((total, num) => total + num, 0);
// filtering
const evens = numbers.filter((num) => num % 2 === 0);
```
### 11. Properties
- Use dot notation when accessing properties.
- Use bracket notation `[]` when accessing properties with a variable.
- Use the exponentiation operator `**` instead of `Math.pow`.
```javascript
const luke = { jedi: true, age: 28 };
// dot notation
const isJedi = luke.jedi;
// bracket notation
const prop = 'jedi';
const isJedi = luke[prop];
// exponentiation
const result = 2 ** 10;
```
### 12. Variables
- Always use `const` or `let`; never use `var`.
- Use one `const` or `let` declaration per variable or assignment.
- Group all `const`s and then group all `let`s.
- Assign variables where you need them, but place them in a reasonable place.
- Don't chain variable assignments.
- Avoid using unary increments (`++`, `--`); use `+= 1` / `-= 1` instead.
- Avoid linebreaks before or after `=` in an assignment.
```javascript
// bad
const items = getItems(),
goSportsTeam = true,
dragonball = 'z';
// good
const items = getItems();
const goSportsTeam = true;
const dragonball = 'z';
// group const then let
const a = 1;
const b = 2;
let c = 3;
let d = 4;
// avoid unary
let count = 0;
count += 1;
```
### 13. Hoisting
- `var` declarations get hoisted; `const` and `let` are in Temporal Dead Zone.
- Named function expressions hoist the variable name but not the function body.
- Function declarations hoist the name and the function body.
### 14. Comparison Operators & Equality
- Use `===` and `!==` over `==` and `!=`.
- Use shortcuts for booleans, but explicit comparisons for strings and numbers.
- Use braces to create blocks in `case` and `default` clauses that contain lexical declarations.
- Ternaries should not be nested and generally be single-line expressions.
- Avoid unneeded ternary statements.
- When mixing operators, enclose them in parentheses (except `**`, `+`, `-`).
```javascript
// bad
if (isValid == true) { /* ... */ }
if (name != '') { /* ... */ }
// good
if (isValid) { /* ... */ }
if (name !== '') { /* ... */ }
if (collection.length > 0) { /* ... */ }
// no nested ternaries
const thing = foo === 123 ? bar : foobar;
```
### 15. Blocks
- Use braces with all multiline blocks.
- Put `else` on the same line as the `if` block's closing brace.
- If an `if` block always executes a `return`, the subsequent `else` block is unnecessary.
```javascript
// bad
if (test)
return false;
// good
if (test) return false;
if (test) {
return false;
}
// if/else
if (test) {
thing1();
} else {
thing2();
}
```
### 16. Control Statements
- If a control statement (`if`, `while`, etc.) gets too long, each grouped condition should be on a new line, with the logical operator at the beginning of the line.
- Don't use selection operators in place of control statements.
```javascript
if (
foo === 123
&& bar === 'abc'
) {
thing1();
}
```
### 17. Comments
- Use `/** ... */` for multiline comments.
- Use `//` for single-line comments. Place them on a new line above the subject.
- Start all comments with a space for readability.
- Prefix comments with `FIXME:` or `TODO:` to annotate problems or suggest actions.
```javascript
// good single line
// This is a comment
const active = true;
/**
* Multiline comment explaining the function.
* @param {string} tag - The tag name.
* @returns {Element} The created element.
*/
function make(tag) {
return document.createElement(tag);
}
// TODO: implement caching
// FIXME: should not use global state
```
### 18. Whitespace
- Use soft tabs (spaces) set to 2 spaces.
- Place 1 space before the leading brace.
- Place 1 space before the opening parenthesis in control statements.
- Set off operators with spaces.
- End files with a single newline character.
- Use indentation when making long method chains (more than 2 method chains).
- Leave a blank line after blocks and before the next statement.
- Do not pad blocks with blank lines.
- Do not use multiple blank lines to pad your code.
- Do not add spaces inside parentheses, brackets.
- Add spaces inside curly braces.
```javascript
// bad
function foo(){
const name='Alice';
}
// good
function foo() {
const name = 'Alice';
}
// method chaining
$('#items')
.find('.selected')
.highlight()
.end()
.find('.open')
.updateCount();
```
### 19. Commas
- Do **not** use leading commas.
- Use trailing commas (dangling commas) for multiline structures.
```javascript
// bad — leading commas
const hero = {
firstName: 'Ada'
, lastName: 'Lovelace'
};
// good — trailing commas
const hero = {
firstName: 'Ada',
lastName: 'Lovelace',
};
const heroes = [
'Batman',
'Superman',
];
```
### 20. Semicolons
- **Always** use semicolons.
```javascript
// bad
const name = 'Alice'
// good
const name = 'Alice';
```
### 21. Type Casting & Coercion
- Perform type coercion at the beginning of the statement.
- Use `String()` for strings, `Number()` for numbers, `Boolean()` or `!!` for booleans.
- Use `parseInt` always with a radix.
```javascript
const val = '4';
// bad
const totalScore = val + 0;
// good
const totalScore = Number(val);
const inputValue = String(someNum);
const hasAge = Boolean(age);
const hasName = !!name;
const count = parseInt(inputValue, 10);
```
### 22. Naming Conventions
- Avoid single-letter names; be descriptive.
- Use **camelCase** for objects, functions, and instances.
- Use **PascalCase** for classes and constructors.
- Use **UPPERCASE_SNAKE_CASE** for constants that are exported and truly immutable.
- Do not use trailing or leading underscores.
- A base filename should exactly match the name of its default export.
- Use **camelCase** when exporting a function; use **PascalCase** when exporting a class / constructor / singleton / function library / bare object.
- Acronyms and initialisms should always be all uppercased or all lowercased.
```javascript
// bad
const OBJEcttsssss = {};
function c() {}
const u = new user();
// good
const thisIsMyObject = {};
function calculateTotal() {}
const user = new User();
// constants
export const API_BASE_URL = 'https://api.example.com';
export const MAX_RETRY_COUNT = 3;
// filename examples
// file: makeStyleGuide.js → export default function makeStyleGuide() {}
// file: User.js → export default class User {}
```
### 23. Accessors
- Accessor functions for properties are not required.
- Do not use JavaScript getters/setters as they cause unexpected side effects.
- If you do make accessor functions, use `getVal()` and `setVal('value')`.
- If the property/method is a boolean, use `isVal()` or `hasVal()`.
```javascript
// bad
dragon.age();
// good
dragon.getAge();
dragon.setAge(25);
dragon.isAlive();
dragon.hasWings();
```
### 24. Events
- When attaching data payloads to events, pass an object (hash) instead of a raw value.
```javascript
// bad
emitter.emit('itemUpdate', item.id);
// good
emitter.emit('itemUpdate', { itemId: item.id });
```
### 25. Promises & Async/Await
- Prefer `async`/`await` over chaining `.then()` and `.catch()`.
- Always handle errors with `try...catch` in `async` functions.
- Avoid mixing callbacks and promises.
- Use `Promise.all` for concurrent independent async operations.
- Use `Promise.allSettled` when you need results of all promises regardless of rejection.
```javascript
// bad
function fetchData() {
return getData()
.then((data) => parseData(data))
.then((parsed) => validate(parsed))
.catch((err) => console.error(err));
}
// good
async function fetchData() {
try {
const data = await getData();
const parsed = await parseData(data);
return validate(parsed);
} catch (err) {
console.error(err);
throw err;
}
}
// concurrent operations
async function loadDashboard() {
const [user, posts, notifications] = await Promise.all([
fetchUser(),
fetchPosts(),
fetchNotifications(),
]);
return { user, posts, notifications };
}
```
### 26. Error Handling
- Only throw `Error` objects (or subclasses of `Error`).
- Always catch errors where they can be meaningfully handled.
- Use custom error classes for domain-specific errors.
```javascript
// bad
throw 'Something went wrong';
throw { message: 'error' };
// good
throw new Error('Something went wrong');
class ValidationError extends Error {
constructor(message, field) {
super(message);
this.name = 'ValidationError';
this.field = field;
}
}
throw new ValidationError('Invalid email', 'email');
```
### 27. Optional Chaining & Nullish Coalescing
- Use optional chaining (`?.`) to access nested properties that may not exist.
- Use nullish coalescing (`??`) instead of `||` when you want to allow falsy values like `0` or `''`.
```javascript
// bad
const city = user && user.address && user.address.city;
const port = config.port || 3000; // breaks if port is 0
// good
const city = user?.address?.city;
const port = config.port ?? 3000;
```
### 28. Standard Library
- Use `Number.isNaN` instead of global `isNaN`.
- Use `Number.isFinite` instead of global `isFinite`.
```javascript
// bad
isNaN('1.2');
isFinite('2e3');
// good
Number.isNaN('1.2');
Number.isFinite('2e3');
```
---
## Usage
This is a **Prompt-based Skill** (natural language activation).
### How to Use
1. **Automatic Activation**: Simply mention "JavaScript" in your request. The skill will be activated automatically.
2. **Ask for Style Guidance**:
```
"How should I write a JavaScript function that fetches user data?"
```
3. **Request Code Review**:
```
"Review this JavaScript code for style issues: [paste code]"
```
4. **Generate Compliant Code**:
```
"Write a JavaScript module to handle form validation"
```
5. **Ask About Specific Rules**:
```
"What's the correct way to declare variables in JavaScript?"
"How should I handle async errors in JavaScript?"
```
### Examples
**User**: Write a JavaScript utility function to deep clone an object.
**Skill Response**: Generates clean, style-guide-compliant code:
```javascript
/**
* Deep clones a plain object or array using structured cloning.
* Falls back to JSON serialization for environments without structuredClone.
*
* @param {Object|Array} source - The value to clone.
* @returns {Object|Array} A deep copy of the source.
*/
function deepClone(source) {
if (typeof structuredClone === 'function') {
return structuredClone(source);
}
return JSON.parse(JSON.stringify(source));
}
export default deepClone;
```
【全栈能力】编程大神.Skill:面向复杂真实项目的高阶全栈编程助手。不止生成代码,而是从一句目标接手陌生代码库,拆解需求、补齐实现、追到根因、完成重构、联调前后端,并把结果推进到能运行、能验证、能交付。覆盖 Web、后端、脚本、iOS、安卓、鸿蒙 ArkUI、微信小程序及其他技术栈,支持中英文工程、疑难 Bug、跨模块任务和长任务续做;用构建、日志、真实入口、设备或接口证据说明结果。仅问概念时直接回答,要求落地时持续推进到验收或明确阻塞。
编程专家 Pro:融合编程专家 2.0.3 工程专题与编程大神的鸿蒙 ArkTS/ArkUI、微信小程序和小游戏开发资料。用于项目实现、根因调试、审查、重构、测试、架构性能分析及多端开发验证。支持自然语言和 @专题标识,按任务读取包内知识;只问概念时直接回答。
编程专家.Skill P8级编程助手,25年实战经验技能Skill,全栈:Java/Php网站/软件项目、API设计、Bug诊断、代码生成、代码审查、重构、测试用例、性能基准、技术选型、文档生成、任务拆解、Spec驱动、Karpathy规范、CMS二次开发、前端设计、MySQL/Mariadb、项目知识图谱,以及工程纪律层(根因调试硬闭环、阶段导航、事故复盘/SLO、威胁建模/供应链安全、生产就绪/渐进式发布、AI编码治理、面向Agent代码可读性、LLM应用安全)。支持 @标识 显式调用跳过路由。
编程专家.Skill P8级编程助手,25年实战经验技能Skill,全栈:Java/Php网站/软件项目、API设计、Bug诊断、代码生成、代码审查、重构、测试用例、性能基准、技术选型、文档生成、任务拆解、Spec驱动、Karpathy规范、CMS二次开发、前端设计、MySQL/Mariadb、项目知识图谱,以及工程纪律层(根因调试硬闭环、阶段导航、事故复盘/SLO、威胁建模/供应链安全、生产就绪/渐进式发布、AI编码治理、面向Agent代码可读性、LLM应用安全)。支持 @标识 显式调用跳过路由。
工程专题、鸿蒙与微信小程序开发的集成派生版
编程专家 Pro:融合编程专家 2.0.3 工程专题与编程大神的鸿蒙 ArkTS/ArkUI、微信小程序和小游戏开发资料。用于项目实现、根因调试、审查、重构、测试、架构性能分析及多端开发验证。支持自然语言和 @专题标识,按任务读取包内知识;只问概念时直接回答。
适用场景:全栈编程助手。接到需求先读现有代码和约束,再动手:Java/PHP 开发、接口设计、缺陷定位、代码评审、重构、测试用例、性能排查、技术选型与文档产出,也做 CMS 二次开发、前端页面和 MySQL 调优。每次改动先给方案和影响范围,改完必须跑验证,交付附交接说明。适合要把代码真正跑通、而不是只要片段的场景。写完代码常要配套的造价、法律、工程文档,站内已有现成技能,用「查找技能」按需求找即可。
gh コマンドラインで GitHub の PR チェック、ワークフロー実行、API 照会を扱うスキルです。
百度網盤のファイルを管理し、すべての操作を指定のアプリディレクトリ内に限定します。
Bilibili の人気監視、取得、投稿を一つの道具箱にまとめた技能です。
六爻の占いで答えるスキルです。
面接官を演じ、目標の職種とレベルに合わせて模擬面接を行います。
断片的な業務メモを構造化された週報にまとめます。
データ月:2026-10 · ダウンロード数とスター数は公開スキルレジストリ(ClawHub、SkillHub)から月単位で集計しています。詳しくはデータの方法論をご覧ください。