ਟੈਕਸਟ ਕੇਸ ਬਦਲੋ _

ਟੈਕਸਟ ਕੇਸ ਰੂਪਾਂਤਰਨ ਕੀ ਹੈ?

ਟੈਕਸਟ ਕੇਸ ਰੂਪਾਂਤਰਨ ਇੱਕ ਇਨਪੁੱਟ ਸਤਰ ਲੈਂਦਾ ਹੈ ਅਤੇ ਉਹੀ ਸ਼ਬਦ ਇੱਕ ਵੱਖਰੇ ਅੱਖਰ-ਕੇਸ ਸੰਮੇਲਨ ਵਿੱਚ ਰੈਂਡਰ ਕਰਕੇ ਬਾਹਰ ਕੱਢਦਾ ਹੈ। ਸਭ ਤੋਂ ਆਮ ਟੀਚੇ ਹਨ camelCase ਅਤੇ PascalCase (ਜ਼ਿਆਦਾਤਰ ਕਰਲੀ-ਬ੍ਰੇਸ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਆਈਡੈਂਟੀਫਾਇਰਾਂ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ), snake_case ਅਤੇ CONSTANT_CASE (Python, Ruby, Rust, C ਮੈਕਰੋਜ਼), kebab-case (URLs, CSS ਕਲਾਸ ਨਾਮ, HTML ਗੁਣ, npm ਪੈਕੇਜ ਨਾਮ), dot.case (ਕੌਂਫਿਗਰੇਸ਼ਨ ਕੁੰਜੀਆਂ, JavaScript ਆਬਜੈਕਟ ਪਾਥ), path/case (ਫਾਈਲਸਿਸਟਮ-ਸ਼ੈਲੀ ਆਈਡੈਂਟੀਫਾਇਰ), Title Case ਅਤੇ Sentence case (ਸੁਰਖੀਆਂ ਅਤੇ ਗੱਦ), ਨਾਲ ਹੀ ਪੂਰਾ lower case ਅਤੇ UPPER CASE। ਇਹ ਰੂਪਾਂਤਰਕ ਤੁਹਾਡੇ ਇਨਪੁੱਟ ਵਿੱਚ ਕੁਦਰਤੀ ਸ਼ਬਦ ਸੀਮਾਵਾਂ ਨੂੰ ਖੋਜਦਾ ਹੈ — ਵਾਈਟਸਪੇਸ, ਹਾਈਫਨ, ਅੰਡਰਸਕੋਰ, ਬਿੰਦੀਆਂ, ਸਲੈਸ਼, ਅਤੇ ਉਹ lowercase→uppercase ਤਬਦੀਲੀਆਂ ਜੋ helloWorld-ਸ਼ੈਲੀ ਆਈਡੈਂਟੀਫਾਇਰਾਂ ਨੂੰ ਚਿੰਨ੍ਹਿਤ ਕਰਦੀਆਂ ਹਨ — ਅਤੇ ਹਰ ਟੀਚਾ ਕੇਸ ਜਿਸ ਵਿਭਾਜਕ ਅਤੇ ਕੈਪੀਟਲਾਈਜ਼ੇਸ਼ਨ ਪੈਟਰਨ ਦੀ ਮੰਗ ਕਰਦਾ ਹੈ ਉਸ ਨਾਲ ਉਨ੍ਹਾਂ ਨੂੰ ਮੁੜ ਜੋੜਦਾ ਹੈ।

ਕੇਸ ਰੂਪਾਂਤਰਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?

ਤੁਹਾਡਾ ਇਨਪੁੱਟ ਇੱਕ ਛੋਟੇ vanilla-JavaScript ਟੋਕੇਨਾਈਜ਼ਰ ਅਤੇ ਗਿਆਰਾਂ ਕੇਸ ਫਾਰਮੈਟਰਾਂ ਵਰਤ ਕੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਪ੍ਰੋਸੈੱਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਉੱਚ-ਪੱਧਰੀ ਕਦਮ ਹਨ:

1. ਤੁਹਾਡਾ ਇਨਪੁੱਟ textarea ਤੋਂ ਜਿਉਂ ਦਾ ਤਿਉਂ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ — ਤੁਸੀਂ ਜੋ ਵੀ ਪੇਸਟ ਕੀਤਾ ਹਰ ਬਾਈਟ ਸਥਾਨਕ ਮੈਮੋਰੀ ਵਿੱਚ ਰੱਖੀ ਜਾਂਦੀ ਹੈ।
2. ਇੱਕ ਟੋਕੇਨਾਈਜ਼ਰ ਇਨਪੁੱਟ ਨੂੰ ਵਾਈਟਸਪੇਸ, ਅੰਡਰਸਕੋਰ, ਹਾਈਫਨ, ਬਿੰਦੀਆਂ, ਅਤੇ ਸਲੈਸ਼ ਉੱਤੇ ਵੰਡਦਾ ਹੈ, ਫਿਰ ਹਰ ਟੁਕੜੇ ਨੂੰ lowercase→uppercase ਸੀਮਾਵਾਂ ਉੱਤੇ ਹੋਰ ਵੰਡਦਾ ਹੈ (ਤਾਂ ਜੋ helloWorld ਬਣ ਜਾਵੇ ["hello", "World"]) ਅਤੇ ਅੱਖਰ↔ਅੰਕ ਸੀਮਾਵਾਂ ਉੱਤੇ (ਤਾਂ ਜੋ v2API ਬਣ ਜਾਵੇ ["v", "2", "API"])।
3. ਖਾਲੀ ਟੋਕਨ ਫਿਲਟਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਬਚੇ ਹੋਏ ਟੋਕਨ String.prototype.toLocaleLowerCase ਵਰਤ ਕੇ ਛੋਟੇ ਅੱਖਰਾਂ ਵਿੱਚ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਤਾਂ ਜੋ ਤੁਰਕੀ, ਜਰਮਨ ਅਤੇ ਹੋਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ Unicode ਅੱਖਰ ਸਹੀ ਸੁਰੱਖਿਅਤ ਰਹਿਣ।
4. ਗਿਆਰਾਂ ਫਾਰਮੈਟਰ ਫਿਰ ਟੋਕਨਾਂ ਨੂੰ ਹਰ ਟੀਚਾ ਕੇਸ ਵਿੱਚ ਇਕੱਠਾ ਕਰਦੇ ਹਨ — camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, dot.case, path/case, Title Case (ਇੱਕ ਛੋਟੇ-ਸ਼ਬਦਾਂ ਦੀ ਸੂਚੀ ਨਾਲ ਤਾਂ ਜੋ and, the, of ਆਦਿ ਛੋਟੇ ਅੱਖਰਾਂ ਵਿੱਚ ਰਹਿਣ ਜਦੋਂ ਤੱਕ ਉਹ ਪਹਿਲਾ ਜਾਂ ਆਖਰੀ ਸ਼ਬਦ ਨਾ ਹੋਣ), Sentence case, ਪੂਰਾ lower case, ਅਤੇ ਪੂਰਾ UPPER CASE।
5. ਆਉਟਪੁੱਟ ਨੂੰ ਨਤੀਜਾ ਗ੍ਰਿੱਡ ਵਿੱਚ ਪ੍ਰਤੀ ਕੇਸ ਇੱਕ ਕਤਾਰ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ; ਹਰ ਕਤਾਰ ਦਾ ਆਪਣਾ ਖੁਦ ਦਾ ਕਾਪੀ ਬਟਨ ਹੁੰਦਾ ਹੈ ਜੋ ਅਸਿੰਕ੍ਰੋਨਸ Clipboard API ਨੂੰ ਪੁਰਾਣੇ ਬ੍ਰਾਊਜ਼ਰਾਂ ਲਈ ਇੱਕ ਸਿੰਕ੍ਰੋਨਸ document.execCommand('copy') ਫਾਲਬੈਕ ਨਾਲ ਵਰਤਦਾ ਹੈ।

ਕੇਸ ਕਨਵਰਟਰ ਕਿਉਂ ਵਰਤੋ?

• ਆਈਡੈਂਟੀਫਾਇਰ ਰਿਫੈਕਟਰ ਕਰੋ: ਇੱਕ-ਇੱਕ ਅੱਖਰ ਹੱਥ ਨਾਲ ਸੰਪਾਦਿਤ ਕੀਤੇ ਬਿਨਾਂ JavaScript ਵੇਰੀਏਬਲ user_id ਤੋਂ userId ਵਿੱਚ, Python ਫੰਕਸ਼ਨ helloWorld ਤੋਂ hello_world ਵਿੱਚ, ਜਾਂ Rust ਕਾਂਸਟੈਂਟ maxBuffer ਤੋਂ MAX_BUFFER ਵਿੱਚ ਬਦਲੋ।
• ਕੌਂਫਿਗਰੇਸ਼ਨ ਕੁੰਜੀਆਂ ਬਦਲੋ: Python ਸੇਵਾ ਲਈ camelCase ਕੁੰਜੀਆਂ ਵਾਲਾ JSON ਕੌਂਫਿਗ ਇੱਕ ਪੇਸਟ ਵਿੱਚ snake_case YAML ਵਿੱਚ ਫਲਿੱਪ ਕਰੋ।
• ਸੁਰਖੀਆਂ ਲਿਖੋ: ਇੱਕ ਡਰਾਫਟ ਸੁਰਖੀ ਪੇਸਟ ਕਰੋ ਅਤੇ Title Case ਫਾਰਮ (Chicago Manual of Style ਦੇ ਛੋਟੇ-ਸ਼ਬਦ ਅਪਵਾਦਾਂ ਨਾਲ) ਨੂੰ Sentence case ਫਾਰਮ (AP Stylebook) ਦੇ ਨਾਲ-ਨਾਲ ਵਾਪਸ ਪੜ੍ਹੋ — ਜੋ ਵੀ ਤੁਹਾਡਾ ਪ੍ਰਕਾਸ਼ਨ ਵਰਤਦਾ ਹੈ ਉਹ ਚੁਣੋ।
• URL ਸਲੱਗ ਬਣਾਓ: ਇੱਕ ਬਲਾਗ ਪੋਸਟ ਸੁਰਖੀ ਪੇਸਟ ਕਰੋ ਅਤੇ kebab-case ਫਾਰਮ ਨੂੰ ਸਿੱਧਾ ਆਪਣੇ CMS ਦੇ ਸਲੱਗ ਫੀਲਡ ਵਿੱਚ ਕਾਪੀ ਕਰੋ — ਟੋਕੇਨਾਈਜ਼ਰ ਪਿੱਛੇ ਭਟਕੇ ਵਿਭਾਜਕ ਛੱਡੇ ਬਿਨਾਂ ਵਿਰਾਮ ਚਿੰਨ੍ਹਾਂ ਅਤੇ ਬਹੁ-ਸ਼ਬਦ ਵਾਕਾਂਸ਼ਾਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।

ਕੇਸ ਰੂਪਾਂਤਰਨ ਦੀਆਂ ਆਮ ਵਰਤੋਂ ਕੀ ਹਨ?

ਅੱਖਰ-ਕੇਸ ਸੰਮੇਲਨਾਂ ਵਿਚਕਾਰ ਬਦਲਣਾ ਸਾਫ਼ਟਵੇਅਰ ਇੰਜੀਨੀਅਰਿੰਗ, ਸਮੱਗਰੀ ਰਚਨਾ ਅਤੇ ਡੇਟਾ ਇੰਜੀਨੀਅਰਿੰਗ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

• ਕੋਡ ਰਿਫੈਕਟਰਿੰਗ: ਜਦੋਂ ਇੱਕ ਸ਼ੈਲੀ ਗਾਈਡ ਬਦਲਦੀ ਹੈ ਤਾਂ ਇੱਕ ਕੋਡਬੇਸ ਵਿੱਚ ਆਈਡੈਂਟੀਫਾਇਰਾਂ ਨੂੰ ਟਾਈਪੋਜ਼ ਪੇਸ਼ ਕੀਤੇ ਬਿਨਾਂ ਮੁੜ ਨਾਮ ਦਿਓ (ਜਿਵੇਂ ਇੱਕ ਬੈਕਐਂਡ ਮੁੜ-ਲਿਖਣ ਦੌਰਾਨ JavaScript camelCase → Python snake_case)।
• API ਪੇਲੋਡ ਮੁੜ-ਆਕਾਰ: Ruby on Rails ਜਾਂ Django ਬੈਕਐਂਡ ਨੂੰ ਖੁਆਉਣ ਤੋਂ ਪਹਿਲਾਂ camelCase JSON ਕੁੰਜੀਆਂ snake_case ਵਿੱਚ ਬਦਲੋ।
• ਸਿਰਲੇਖ ਅਤੇ ਸਲੱਗ ਰਚਨਾ: ਇੱਕੋ ਸਰੋਤ ਸਿਰਲੇਖ ਤੋਂ ਇੱਕ ਕਦਮ ਵਿੱਚ Title Case ਪੇਜ ਸਿਰਲੇਖ, Sentence case ਮੈਟਾ ਵੇਰਵੇ ਅਤੇ kebab-case URL ਸਲੱਗ ਪੈਦਾ ਕਰੋ।

ਕੇਸ ਰੂਪਾਂਤਰਨ ਉਦਾਹਰਨ ਕਿਹੋ ਜਿਹੀ ਦਿਖਦੀ ਹੈ?

ਇਨਪੁੱਟ ਵਿੱਚ Hello World API ਪੇਸਟ ਕਰੋ। ਨਤੀਜਾ ਗਰਿੱਡ ਗਿਆਰਾਂ ਕਤਾਰਾਂ ਇੱਕੋ ਸਮੇਂ ਦਿਖਾਉਂਦਾ ਹੈ: helloWorldApi (camelCase), HelloWorldApi (PascalCase), hello_world_api (snake_case), HELLO_WORLD_API (CONSTANT_CASE), hello-world-api (kebab-case), hello.world.api (dot.case), hello/world/api (path/case), Hello World Api (Title Case), Hello world api (Sentence case), hello world api (lower case), ਅਤੇ HELLO WORLD API (UPPER CASE)। ਉਹੀ ਇਨਪੁੱਟ helloWorldAPI ਵਜੋਂ ਪੇਸਟ ਕਰਨ ਨਾਲ ਵੀ ਉਹੀ ਤਿੰਨ ਸ਼ਬਦ ਮਿਲਦੇ ਹਨ — lowercase→uppercase ਸੀਮਾ ਖੋਜਕ ਇਸ ਆਕਾਰ ਨੂੰ ਵੀ ਸੰਭਾਲਦਾ ਹੈ।

ਕੀ ਇਹ ਮੇਰੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਚੱਲਦਾ ਹੈ?

ਹਾਂ। ਟੋਕੇਨਾਈਜ਼ਰ ਅਤੇ ਗਿਆਰਾਂ ਕੇਸ ਫਾਰਮੈਟਰ ਬ੍ਰਾਊਜ਼ਰ ਟੈਬ ਵਿੱਚ ਚੱਲਦੇ vanilla JavaScript ਦੀਆਂ ਲਗਭਗ 120 ਲਾਈਨਾਂ ਹਨ। ਕੁਝ ਵੀ ਅਪਲੋਡ ਨਹੀਂ ਹੁੰਦਾ, ਅਤੇ ਕਨਵਰਟ ਕਦਮ ਲਈ ਪੇਜ ਕੋਈ ਨੈੱਟਵਰਕ ਬੇਨਤੀ ਨਹੀਂ ਕਰਦਾ। ਤੁਹਾਡਾ ਟੈਕਸਟ ਕਦੇ Ultim8Soft ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦਾ।

ਮੈਨੂੰ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਲਈ ਕਿਹੜਾ ਕੇਸ ਫਾਰਮੈਟ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ?

ਇਹ ਭਾਸ਼ਾ ਅਤੇ ਟੀਮ ਦੀ ਸ਼ੈਲੀ ਗਾਈਡ ਉੱਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। JavaScript ਅਤੇ TypeScript ਕੋਡਬੇਸ ਭਾਰੀ ਬਹੁਮਤ ਨਾਲ ਵੇਰੀਏਬਲਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਲਈ camelCase, ਕਲਾਸਾਂ ਅਤੇ React ਕੰਪੋਨੈਂਟਾਂ ਲਈ PascalCase, ਅਤੇ ਵਾਤਾਵਰਨ-ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਅਤੇ ਮੌਡਿਊਲ-ਪੱਧਰ ਦੇ ਸਥਿਰਾਂਕਾਂ ਲਈ CONSTANT_CASE ਵਰਤਦੇ ਹਨ — Google JavaScript ਸ਼ੈਲੀ ਗਾਈਡ ਅਤੇ Airbnb ਸ਼ੈਲੀ ਗਾਈਡ ਦੋਵੇਂ ਇਨ੍ਹਾਂ ਚੋਣਾਂ ਨੂੰ ਪੱਕਾ ਕਰਦੇ ਹਨ। Python (PEP 8), Ruby, ਅਤੇ Rust ਵੇਰੀਏਬਲਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਲਈ snake_case, ਕਲਾਸਾਂ ਲਈ PascalCase, ਅਤੇ ਮੌਡਿਊਲ-ਪੱਧਰ ਦੇ ਸਥਿਰਾਂਕਾਂ ਲਈ CONSTANT_CASE ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੇ ਹਨ। C ਅਤੇ C++ ਕੋਡਬੇਸ (Linux kernel, LLVM) ਫੰਕਸ਼ਨਾਂ ਲਈ snake_case ਅਤੇ ਪ੍ਰੀਪ੍ਰੋਸੈਸਰ ਮੈਕਰੋਜ਼ ਲਈ CONSTANT_CASE ਉੱਤੇ ਟਿਕਦੇ ਹਨ। ਜਦੋਂ ਸ਼ੱਕ ਹੋਵੇ, ਤਾਂ ਆਪਣੀ ਟੀਮ ਦਾ ਲਿੰਟਰ ਜਾਂ ਫਾਰਮੈਟਰ ਚਲਾਓ — ਇਹ ਤੁਹਾਨੂੰ ਦੱਸੇਗਾ ਕਿ ਕਿਹੜਾ ਸੰਮੇਲਨ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ।

ਇਨਪੁੱਟ ਕਿਵੇਂ ਟੋਕੇਨਾਈਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ?

ਟੋਕੇਨਾਈਜ਼ਰ ਪਹਿਲਾਂ ਇਨਪੁੱਟ ਨੂੰ ਵਾਈਟਸਪੇਸ, ਅੰਡਰਸਕੋਰ (_), ਹਾਈਫਨ (-), ਬਿੰਦੀ (.), ਜਾਂ ਸਲੈਸ਼ (/) ਦੀ ਕਿਸੇ ਵੀ ਲੜੀ ਉੱਤੇ ਵੰਡਦਾ ਹੈ। ਹਰ ਨਤੀਜਾ ਟੁਕੜਾ ਫਿਰ lowercase→uppercase ਸੀਮਾਵਾਂ ਉੱਤੇ (ਤਾਂ ਜੋ helloWorld ਬਣ ਜਾਵੇ ["hello", "World"]) ਅਤੇ ਅੱਖਰ↔ਅੰਕ ਸੀਮਾਵਾਂ ਉੱਤੇ (ਤਾਂ ਜੋ v2API ਬਣ ਜਾਵੇ ["v", "2", "API"]) ਦੁਬਾਰਾ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। ਖਾਲੀ ਟੋਕਨ ਫਿਲਟਰ ਕਰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਬਚੇ ਹੋਏ ਟੋਕਨ String.prototype.toLocaleLowerCase ਰਾਹੀਂ ਲੋਅਰਕੇਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਫਿਰ ਫਾਰਮੈਟਰ ਟੋਕਨਾਂ ਨੂੰ ਮੁੜ-ਕੈਪੀਟਲਾਈਜ਼ ਕਰਦੇ ਹਨ ਅਤੇ ਹਰ ਟੀਚਾ ਕੇਸ ਜਿਸ ਵਿਭਾਜਕ ਦੀ ਮੰਗ ਕਰਦਾ ਹੈ ਉਸ ਨਾਲ ਮੁੜ-ਜੋੜਦੇ ਹਨ। ਇਹ ਰਣਨੀਤੀ ਸਾਰੇ ਛੇ ਆਮ ਆਈਡੈਂਟੀਫਾਇਰ ਆਕਾਰਾਂ ਨੂੰ ਸੰਭਾਲਦੀ ਹੈ — camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, ਅਤੇ ਸਾਦਾ ਸਪੇਸ-ਨਾਲ-ਵੱਖ ਕੀਤਾ ਗੱਦ — ਬਾਹਰ-ਬਕਸੇ ਤੋਂ।

Unicode / ਗੈਰ-ASCII ਅੱਖਰਾਂ ਬਾਰੇ ਕੀ?

Unicode ਅੱਖਰ ਰਾਊਂਡ ਟ੍ਰਿੱਪ ਤੋਂ ਬਚ ਜਾਂਦੇ ਹਨ। ਟੋਕੇਨਾਈਜ਼ਰ String.prototype.toLocaleLowerCase ਅਤੇ toLocaleUpperCase ਵਰਤਦਾ ਹੈ, ਜੋ ਭਾਸ਼ਾ-ਵਿਸ਼ੇਸ਼ ਕੇਸਿੰਗ ਨਿਯਮਾਂ ਦਾ ਸਨਮਾਨ ਕਰਦੇ ਹਨ — ਤੁਰਕੀ ਬਿੰਦੀ ਵਾਲਾ ਬਨਾਮ ਬਿੰਦੀ ਰਹਿਤ i, ਜਰਮਨ ß ਦਾ SS ਵਿੱਚ ਅੱਪਰ-ਕੇਸ ਹੋਣਾ, ਫ੍ਰੈਂਚ ਅਤੇ ਸਪੈਨਿਸ਼ ਵਿੱਚ ਐਕਸੈਂਟ ਵਾਲੇ ਲਾਤੀਨੀ ਅੱਖਰ, ਅਤੇ ਇਸੇ ਤਰ੍ਹਾਂ ਹੋਰ। ਉਹ ਗੈਰ-ਅੱਖਰ ਅੱਖਰ ਜੋ ਵਿਭਾਜਕ ਸੈੱਟ (ਵਾਈਟਸਪੇਸ, _, -, ., /) ਵਿੱਚ ਨਹੀਂ ਹਨ — ਉਦਾਹਰਨ ਲਈ ਅੰਕ, ਐਕਸੈਂਟ ਵਾਲੇ ਅੱਖਰ, ਜਾਂ CJK ਅੱਖਰ — ਉਸ ਟੋਕਨ ਦੇ ਅੰਦਰ ਰੱਖੇ ਜਾਂਦੇ ਹਨ ਜਿਸ ਵਿੱਚ ਉਹ ਪ੍ਰਗਟ ਹੁੰਦੇ ਹਨ ਅਤੇ ਕੇਸ ਫਾਰਮੈਟਰ ਉਨ੍ਹਾਂ ਨੂੰ ਹੂਬਹੂ ਮੁੜ-ਬਾਹਰ ਕੱਢਦੇ ਹਨ। ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ nœud_principal ਜਿਹਾ ਇੱਕ ਇਨਪੁੱਟ ["nœud", "principal"] ਵਿੱਚ ਟੋਕੇਨਾਈਜ਼ ਹੁੰਦਾ ਹੈ ਅਤੇ ਸਾਫ਼-ਸੁਥਰੇ ਤੌਰ ਉੱਤੇ nœudPrincipal (camelCase) ਜਾਂ NœudPrincipal (PascalCase) ਵਿੱਚ ਬਦਲ ਜਾਂਦਾ ਹੈ।

ਇਹ ਕੇਸ ਕਨਵਰਟਰ ਇੱਕ ਸਿੰਗਲ ਸਥਿਰ ਪੇਜ ਹੈ ਜੋ ਟੋਕੇਨਾਈਜ਼ਰ ਅਤੇ ਗਿਆਰਾਂ ਫਾਰਮੈਟਰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਚਲਾਉਂਦਾ ਹੈ — ਕੋਈ ਵੈਂਡਰ ਲਾਇਬ੍ਰੇਰੀ ਨਹੀਂ, ਕੋਈ ਨੈੱਟਵਰਕ ਕਾਲ ਨਹੀਂ, ਕੋਈ ਖਾਤਾ ਨਹੀਂ। ਉੱਪਰ ਕੋਈ ਵੀ ਟੈਕਸਟ ਪੇਸਟ ਕਰੋ, ਗਿਆਰਾਂ ਕੇਸ ਆਉਟਪੁੱਟ ਨਾਲ-ਨਾਲ ਦੇਖੋ, ਅਤੇ ਜੋ ਚਾਹੀਦਾ ਉਹ ਕਾਪੀ ਕਰੋ।