Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

8.0 KB
Raw Blame
import { memo } from 'react'

import { useMDXComponents } from 'scenes/onboarding/shared/OnboardingDocsContentWrapper'

export const ExperimentImplementationSnippet = memo(
    ({ language = 'javascript' }: { language?: string }): JSX.Element => {
        const { CodeBlock, dedent } = useMDXComponents()

        const snippets: Record<string, string> = {
            javascript: dedent`
            if (posthog.getFeatureFlag('your-experiment-feature-flag') === 'test') {
                // Do something differently for this user
            } else {
                // It's a good idea to let control variant always be the default behaviour,
                // so if something goes wrong with flag evaluation, you don't break your app.
            }

            // Test that it works
            posthog.featureFlags.overrideFeatureFlags({ flags: {'your-experiment-feature-flag': 'test'} })
        `,
            react: dedent`
            // You can either use the useFeatureFlagVariantKey hook,
            // or you can use the feature flags component - https://posthog.com/docs/libraries/react#feature-flags-react-component

            // Method one: using the useFeatureFlagVariantKey hook
            import { useFeatureFlagVariantKey } from '@posthog/react'

            function App() {
                const variant = useFeatureFlagVariantKey('your-experiment-feature-flag')
                if (variant === 'test') {
                    // do something
                }
            }

            // Method two: using the feature flags component
            import { PostHogFeature } from '@posthog/react'

            function App() {
                return (
                    <PostHogFeature flag='your-experiment-feature-flag' match='test'>
                        <div>
                            {/* the component to show */}
                        </div>
                    </PostHogFeature>
                )
            }

            // You can also test your code by overriding the feature flag:
            posthog.featureFlags.overrideFeatureFlags({ flags: {'your-experiment-feature-flag': 'test'} })
        `,
            'react-native': dedent`
            if (posthog.getFeatureFlag('your-experiment-feature-flag') === 'test') {
                // Do something differently for this user
            } else {
                // It's a good idea to let control variant always be the default behaviour,
                // so if something goes wrong with flag evaluation, you don't break your app.
            }
        `,
            'node.js': dedent`
            import { PostHog } from 'posthog-node'

            const client = new PostHog('<ph_project_token>', { host: '<ph_client_api_host>' })

            const experimentFlagValue = await client.getFeatureFlag('your-experiment-feature-flag', 'user distinct id')

            if (experimentFlagValue === 'test' ) {
                // Do something differently for this user
            } else {
                // It's a good idea to let control variant always be the default behaviour,
                // so if something goes wrong with flag evaluation, you don't break your app.
            }

            // Flush before the handler returns, so the exposure event is not lost.
            // In serverless environments, also set flushAt: 1 and flushInterval: 0 on the client.
            await client.shutdown()
        `,
            python: dedent`
            experiment_flag_value = posthog.get_feature_flag("your-experiment-feature-flag", "user_distinct_id")

            if experiment_flag_value == 'test':
                # Do something differently for this user
            else:
                # It's a good idea to let control variant always be the default behaviour,
                # so if something goes wrong with flag evaluation, you don't break your app.
        `,
            php: dedent`
            if (PostHog::getFeatureFlag('your-experiment-feature-flag', 'user distinct id') == 'test') {
                // Do something differently for this user
            } else {
                // It's a good idea to let control variant always be the default behaviour,
                // so if something goes wrong with flag evaluation, you don't break your app.
            }
        `,
            ruby: dedent`
            experimentFlagValue = posthog.get_feature_flag('your-experiment-feature-flag', 'user distinct id')

            if experimentFlagValue == 'test'
                # Do something differently for this user
            else
                # It's a good idea to let control variant always be the default behaviour,
                # so if something goes wrong with flag evaluation, you don't break your app.
            end
        `,
            go: dedent`
            experimentFlagValue, err := client.GetFeatureFlag(posthog.FeatureFlagPayload{
                Key:        "your-experiment-feature-flag",
                DistinctId: "distinct-id",
            })
            if err != nil {
                // Handle error (e.g. capture error and fallback to default behaviour)
            }
            if experimentFlagValue == "test" {
                // Do something differently for this user
            } else {
                // It's a good idea to let control variant always be the default behaviour,
                // so if something goes wrong with flag evaluation, you don't break your app.
            }
        `,
            dotnet: dedent`
            var flags = await posthog.EvaluateFlagsAsync("distinct-id");

            if (flags.GetFlag("your-experiment-feature-flag")?.VariantKey == "test")
            {
                // Do something differently for this user
            }
            else
            {
                // It's a good idea to let control variant always be the default behaviour,
                // so if something goes wrong with flag evaluation, you don't break your app.
            }
        `,
            android: dedent`
            if (PostHog.getFeatureFlag("your-experiment-feature-flag") == "test") {
                // do something
            } else {
                // It's a good idea to let control variant always be the default behaviour,
                // so if something goes wrong with flag evaluation, you don't break your app.
            }
        `,
            ios: dedent`
            if (PostHogSDK.shared.getFeatureFlag("your-experiment-feature-flag") as? String == "test") {
                // do something
            } else {
                // It's a good idea to let control variant always be the default behaviour,
                // so if something goes wrong with flag evaluation, you don't break your app.
            }
        `,
            flutter: dedent`
            if (await Posthog().getFeatureFlag('your-experiment-feature-flag') == 'test') {
                // Do something differently for this user
            } else {
                // It's a good idea to let control variant always be the default behaviour,
                // so if something goes wrong with flag evaluation, you don't break your app.
            }
        `,
            kmp: dedent`
            if (PostHog.getFeatureFlag("your-experiment-feature-flag") == "test") {
                // do something
            } else {
                // It's a good idea to let control variant always be the default behaviour,
                // so if something goes wrong with flag evaluation, you don't break your app.
            }
        `,
        }

        const langMap: Record<string, string> = {
            javascript: 'javascript',
            react: 'jsx',
            'react-native': 'javascript',
            'node.js': 'javascript',
            python: 'python',
            php: 'php',
            ruby: 'ruby',
            go: 'go',
            dotnet: 'csharp',
            android: 'kotlin',
            ios: 'swift',
            flutter: 'dart',
            kmp: 'kotlin',
        }

        return (
            <CodeBlock language={langMap[language] || 'javascript'} code={snippets[language] || snippets.javascript} />
        )
    }
)